Horizon LabsHorizon Labs
Back to Insights
23 Nov 2026Updated 23 Nov 20267 min read

Micro-Frontend Architecture: Modernising Legacy UIs

Micro-frontend architecture lets teams decompose a legacy UI into independently built and deployed units — but it only pays off under specific conditions. Here's when the pattern genuinely helps, how to integrate it, and what it costs operationally.

Micro-Frontend Architecture: Modernising Legacy UIs

Micro-frontend architecture is a pattern for decomposing a web application's user interface into smaller, independently built and deployed units, each typically owned by a single team and composed together at build time, runtime, or render time into one experience for the end user. It applies the same decomposition logic that microservices apply to back-end systems, but to the presentation layer. For teams working through application modernisation, it offers a way to address a slow, brittle legacy front-end incrementally, without committing to a full platform rewrite. This article covers when the pattern genuinely helps, how to integrate it into an existing monolith, and the operational cost that comes with it.

What is micro-frontend architecture?

The goal of a micro-frontend split is not smaller code for its own sake — it is independent deployability, so one team can ship a change to the checkout flow without waiting on a release train owned by another team. Each micro-frontend is typically built, tested, and deployed by a single team, with clear ownership boundaries and its own release cadence. The units are then composed into a single experience for the end user, using one of several integration approaches covered below. This separates the organisational problem (which team owns which part of the UI) from the technical problem (how the pieces fit together on screen), which is often the real source of friction in a legacy front-end shared across multiple squads.

When does micro-frontend architecture actually help?

Micro-frontends earn their complexity when multiple teams need to ship UI changes to the same application independently, and a shared monolithic front-end has become the bottleneck. Typical signals include a single front-end codebase owned by several squads, release cycles that are blocked by unrelated work, or a long-running modernisation effort where some areas of the UI can move to a new stack while others stay on the old one.

This last case is the one most relevant to legacy modernisation. Instead of rewriting an entire front-end in one project, a team can carve off a single page, flow, or section — say, the billing dashboard or a new onboarding flow — build it as an isolated micro-frontend on a modern stack, and route users into it while the rest of the application continues running on the legacy codebase. This is effectively the strangler fig pattern applied to the UI layer: new functionality is grown around the old system until the old system can be retired piece by piece, rather than replaced in one high-risk cutover.

When should you avoid it?

Micro-frontends are not the default answer to a slow or dated UI, and teams should be honest about that before committing. If a single team owns the entire front-end, if the application is small enough that one codebase is still manageable, or if the main problem is technical debt within a single stack rather than cross-team coordination, a micro-frontend split usually adds coordination overhead without solving the underlying problem. In those cases, targeted refactoring, componentisation within the existing framework, or a straightforward framework upgrade will typically get further for less cost than standing up a new architectural layer.

The pattern also assumes a reasonable level of engineering maturity — shared design systems, CI/CD pipelines that can handle multiple independently deployed artefacts, and clear ownership boundaries between teams. Without that foundation, a micro-frontend split can fragment the user experience (inconsistent styling, duplicated dependencies, slower page loads) faster than it delivers independence.

How do you integrate micro-frontends into a legacy application?

There is no single correct integration approach — the right choice depends on how much isolation you need versus how much shared state and styling consistency matters to the product. The main approaches in use today are build-time composition, runtime composition (commonly via Webpack Module Federation or similar), server-side composition at the edge, and iframe- or Web Component-based isolation. Web Components themselves are a W3C browser standard for creating reusable, encapsulated custom elements, which makes them a common neutral integration layer between frontends built on different frameworks.

ApproachDeployment independenceRuntime isolationShared state complexityTypical fit
Build-time composition (npm packages)Lower — requires a rebuild of the hostHighLowerSmall number of stable, slow-changing modules
Runtime composition (Module Federation)HighMediumMedium–higherMultiple teams shipping independently on a shared framework
Server-side / edge compositionHighMediumMediumContent-heavy pages, SEO-sensitive routes
iframe or Web Component isolationHighHighestLowerStrict isolation needs, mixed tech stacks, legacy embeds

For most legacy modernisation projects, teams start with the approach that requires the least change to the existing system — often iframe or Web Component isolation for the first carved-off module — and move toward runtime composition as confidence and shared tooling mature.

What are the operational trade-offs?

Micro-frontends trade a single point of coordination for several points of independent failure, and that trade-off has to be managed deliberately rather than assumed away. Expect increased complexity in testing (end-to-end tests now span multiple independently deployed artefacts), a real risk of duplicated dependencies inflating bundle size if shared libraries are not versioned carefully, and the need for a consistent design system to avoid a visibly fragmented product. Observability also has to extend across the boundary — a performance regression in one micro-frontend can be invisible to teams owning the others unless monitoring is set up end-to-end.

This is also where ai engineering disciplines around CI/CD, monitoring, and release automation become directly relevant — the same operational rigour that production AI systems require (versioned dependencies, automated testing across service boundaries, end-to-end observability) is exactly what makes a multi-team micro-frontend split sustainable rather than fragile. None of this is a reason to avoid the pattern where it fits. It is a reason to treat the operational cost as part of the decision, not an afterthought discovered after the first module ships.

How does this fit a broader modernisation strategy?

The decision to adopt micro-frontends should follow from the underlying business and product goals, not precede them. Before committing to the pattern, it is worth asking what problem is actually being solved: is it team autonomy and release velocity, or is it a stepping stone toward retiring a legacy system entirely? These questions sit closer to ai product strategy and platform strategy more broadly than to front-end tooling — the architectural choice should serve a clear roadmap for which parts of the product need to move fast, which need to stay stable, and in what order the legacy system gets replaced.

In practice, the most successful micro-frontend adoptions we see start small: one team, one carved-off module, proven integration tooling, and a clear rollback path if the approach does not hold up under real traffic. Only once that first module is stable in production does it make sense to extend the pattern to additional teams and sections of the application. Treated this way, micro-frontend architecture becomes one tool within a longer modernisation roadmap — useful where team structure and release cadence genuinely demand independence, and unnecessary where they do not.

For more on sequencing a legacy modernisation effort, including how to decide what to carve off first and how to measure progress, see more insights from our team.

If you are weighing up whether micro-frontends are the right fit for your legacy UI, or want a second opinion on an integration approach you are already considering, get in touch and we can talk through where your application actually sits on this spectrum.

Share

Chris Kerr

Partner at Horizon Labs, an AI product consultancy and venture studio. A commercially focused product and technology leader with 20+ years building and scaling digital platforms, teams, and businesses across SaaS, travel, eCommerce, logistics and transport, and digital marketing — operating at the intersection of product, engineering, and data. Writes about platform strategy, AI transformation, modern data ecosystems, and the operational discipline that separates AI demos from AI products.