Comparison matrix

Compare approaches

Every rating is 1–5 with a reason behind it. Pick two or three approaches to compare side by side, highlight where they differ, and choose any rating to see why.

Swipe to compare · 8 cards

Ratings are editorial judgement for a typical team, not benchmarks.

Every rating explained

The reason and sources behind each rating, per approach.

Build-time packages
Team independence: 2/5 (higher is better)
Teams publish packages on their own, but nothing reaches users until the shell rebuilds and releases. Sources: Micro Frontends
Runtime performance: 5/5 (higher is better)
One build produces one bundle, with shared dependencies deduplicated when the packages accept the same versions. Sources: Micro Frontends
Complexity: 1/5 (lower is simpler)
Only packages and a normal build; there is no runtime loader to run. Sources: Micro Frontends
SSR / SEO support: 5/5 (higher is better)
The result is one ordinary app, so any server rendering setup works as usual. Sources: Micro Frontends
Tech-agnostic: 1/5 (higher is better)
Packages are compiled into the shell, so they share its framework and version. Sources: Micro Frontends
Isolation: 1/5 (higher is better)
All code runs in one bundle and one page, so styles, globals and errors are shared. Sources: Micro Frontends
UX consistency: 5/5 (higher is better)
One app with one design system makes a consistent experience the default. Sources: Micro Frontends
Tooling maturity: 5/5 (higher is better)
Uses the standard package registry and build tooling every frontend team already has. Sources: Micro Frontends
Read about Build-time packages →
Module Federation
Team independence: 4/5 (higher is better)
Each remote is a separate build that deploys on its own; the shell loads whatever is deployed at runtime. Sources: Module Federation
Runtime performance: 3/5 (higher is better)
Each remote adds requests when it loads, while shared singletons avoid downloading the same library twice. Sources: ModuleFederationPlugin
Complexity: 4/5 (lower is simpler)
You negotiate shared versions, manage remote URLs per environment, and handle remotes that fail to load. Sources: ModuleFederationPlugin
SSR / SEO support: 3/5 (higher is better)
Server rendering is possible but needs extra setup beyond the client-side loading the docs describe. Sources: Module Federation — Introduction
Tech-agnostic: 2/5 (higher is better)
Mixing frameworks is technically possible, but sharing works best when every build uses the same framework. Sources: ModuleFederationPlugin
Isolation: 2/5 (higher is better)
Remotes run in the same page and share globals, styles and the share scope. Sources: Module Federation
UX consistency: 4/5 (higher is better)
Remotes render into one page and can share a design system as a shared dependency. Sources: ModuleFederationPlugin
Tooling maturity: 4/5 (higher is better)
Built into webpack and supported by Rspack and a Vite plugin, with a dedicated project that adds a runtime, manifest and devtools. Sources: Module Federation, Module Federation — Introduction, Vite — Module Federation integrations
Read about Module Federation →
Native Federation / import maps
Team independence: 4/5 (higher is better)
Each remote builds and deploys on its own, and the shell finds it through the manifest at runtime. Sources: Runtime — Native Federation Docs
Runtime performance: 3/5 (higher is better)
Each remote adds module requests when it loads, while shared libraries resolve to one copy through the import map. Sources: Core — Native Federation Docs, <script type="importmap">
Complexity: 3/5 (lower is simpler)
Schematics set up hosts and remotes, but shared versions, manifests per environment and failing remotes are still yours to handle. Sources: Angular adapter — Native Federation Docs
SSR / SEO support: 3/5 (higher is better)
The Angular adapter supports server rendering and hydration, with setup beyond a client-only host. Sources: SSR & Hydration — Native Federation Docs
Tech-agnostic: 2/5 (higher is better)
The core is framework-agnostic, but sharing works best when every remote uses the same framework, and most tooling is Angular's. Sources: Core — Native Federation Docs, Angular adapter — Native Federation Docs
Isolation: 2/5 (higher is better)
Remotes run as modules in the same page and share globals and styles. Sources: Core — Native Federation Docs
UX consistency: 4/5 (higher is better)
Remotes render into one page and can share a design system as a shared library. Sources: Angular adapter — Native Federation Docs
Tooling maturity: 3/5 (higher is better)
Maintained documentation, schematics and adapters, with a smaller ecosystem than Module Federation outside Angular. Sources: Angular adapter — Native Federation Docs, Core — Native Federation Docs
Read about Native Federation / import maps →
single-spa
Team independence: 4/5 (higher is better)
Each application is loaded by the root config from its own build, so it can deploy separately. Sources: Configuring single-spa
Runtime performance: 2/5 (higher is better)
Several frameworks and their lifecycles on one page can add up to a lot of JavaScript. Sources: Getting Started with single-spa
Complexity: 4/5 (lower is simpler)
You own the root config, each application's lifecycle functions, routing and shared libraries. Sources: Getting Started with single-spa
SSR / SEO support: 2/5 (higher is better)
Server rendering relies on the optional layout engine and needs extra setup. Sources: Getting Started with single-spa
Tech-agnostic: 5/5 (higher is better)
Designed to run applications in different frameworks on one page. Sources: Getting Started with single-spa
Isolation: 2/5 (higher is better)
Applications share one page, so styles and globals can collide unless teams scope them. Sources: Getting Started with single-spa
UX consistency: 3/5 (higher is better)
Different frameworks make a shared design system harder to apply everywhere. Sources: Getting Started with single-spa
Tooling maturity: 3/5 (higher is better)
Established documentation, project generator and framework helpers, but no stable release since September 2024. Sources: Getting Started with single-spa, single-spa releases
Read about single-spa →
Web Components
Team independence: 3/5 (higher is better)
Teams can deploy element scripts on their own, but nothing in the standard loads them at runtime, so independence depends on how you deliver those scripts. Sources: Micro Frontends – extending the microservice idea to frontend development, Using custom elements
Runtime performance: 3/5 (higher is better)
Each team's script is another request, and teams that each bundle a framework ship it more than once. Sources: Using custom elements
Complexity: 3/5 (lower is simpler)
The element API is small, but loading scripts, versioning tags and passing rich data are left to you. Sources: Using custom elements, Micro Frontends – extending the microservice idea to frontend development
SSR / SEO support: 2/5 (higher is better)
Elements usually render in the browser; declarative Shadow DOM allows server output but needs support from each team's tooling. Sources: Using shadow DOM
Tech-agnostic: 4/5 (higher is better)
Any framework can render or wrap a custom element, though frameworks differ in how they pass properties and handle events. Sources: Using custom elements, Micro Frontends – extending the microservice idea to frontend development
Isolation: 4/5 (higher is better)
Shadow DOM keeps selectors and markup apart in both directions, but inherited styles and custom properties pass in, and scripts and element names still share one page. Sources: Using shadow DOM, Using custom elements
UX consistency: 3/5 (higher is better)
Global selectors stop at the shadow boundary, so a shared design system has to be built into every element, or passed in as CSS custom properties, which do cross it. Sources: Using shadow DOM
Tooling maturity: 4/5 (higher is better)
Supported natively by browsers and well documented, with libraries available to cut boilerplate. Sources: Using custom elements
Read about Web Components →
iframes
Team independence: 5/5 (higher is better)
Every frame is a separate app, served and deployed by its own team. Sources: Micro Frontends
Runtime performance: 1/5 (higher is better)
Each frame loads its own document and resources and needs extra memory. Sources: <iframe>: The Inline Frame element
Complexity: 2/5 (lower is simpler)
Embedding is easy; sizing, routing and messaging between frames are the hard parts. Sources: Micro Frontends
SSR / SEO support: 2/5 (higher is better)
A frame's page can be server-rendered, but search engines index it separately from the page that embeds it, so the embedding page doesn't get credit for that content. Sources: <iframe>: The Inline Frame element
Tech-agnostic: 5/5 (higher is better)
Anything that can render a web page can be framed. Sources: <iframe>: The Inline Frame element
Isolation: 5/5 (higher is better)
Each frame has its own document, so styles and globals don't interfere, and sandbox can restrict it further. A same-site frame can still share the page's main thread, so a frame that hangs can freeze the page. Sources: Micro Frontends, <iframe>: The Inline Frame element
UX consistency: 1/5 (higher is better)
Integrating parts across frames is difficult, and responsive layout and deep links get harder. Sources: Micro Frontends
Tooling maturity: 5/5 (higher is better)
Built into every browser, with no framework or build tool needed. Sources: <iframe>: The Inline Frame element
Read about iframes →
Server and edge composition
Team independence: 4/5 (higher is better)
Each team deploys the service that renders its fragment, and the composer includes whatever it currently serves. Sources: Micro Frontends – extending the microservice idea to frontend development
Runtime performance: 4/5 (higher is better)
The browser gets one complete page without client-side assembly, but every fragment fetch adds to the server's response time. Sources: Module ngx_http_ssi_module, esi (VCL statement)
Complexity: 4/5 (lower is simpler)
You run and monitor a composing layer, handle timeouts and fallbacks, and still coordinate client-side scripts. Sources: Module ngx_http_ssi_module, ESI Language Specification 1.0
SSR / SEO support: 5/5 (higher is better)
Composition happens on the server or edge, so the first response is already complete HTML. Sources: ESI Language Specification 1.0, Module ngx_http_ssi_module
Tech-agnostic: 5/5 (higher is better)
The composer only sees HTML, so each team can render its fragment with any server technology. Sources: ESI Language Specification 1.0, Micro Frontends – extending the microservice idea to frontend development
Isolation: 3/5 (higher is better)
A failing fragment can be replaced by fallback content, but once assembled, fragments share one page, its styles and its scripts. Sources: ESI Language Specification 1.0, Module ngx_http_ssi_module
UX consistency: 3/5 (higher is better)
Fragments land in one page, but each team renders its own markup, so a consistent look depends on a shared design system. Sources: Micro Frontends – extending the microservice idea to frontend development
Tooling maturity: 3/5 (higher is better)
SSI and ESI are long established and supported by common servers and CDNs, but support for ESI features varies by vendor. Sources: Module ngx_http_ssi_module, esi (VCL statement), ESI Language Specification 1.0
Read about Server and edge composition →
Modular monolith and monorepo
Team independence: 2/5 (higher is better)
Teams own their modules, but everything still ships in one release. Sources: Enforce Module Boundaries
Runtime performance: 5/5 (higher is better)
One app, built once, with no runtime composition cost. Sources: Micro Frontends
Complexity: 2/5 (lower is simpler)
A normal app plus boundary rules to define and keep in CI. Sources: Enforce Module Boundaries
SSR / SEO support: 5/5 (higher is better)
It is one ordinary app, so any server rendering setup works as usual. Sources: Micro Frontends
Tech-agnostic: 1/5 (higher is better)
One build means one framework for the whole app. Sources: Micro Frontends
Isolation: 1/5 (higher is better)
Boundaries apply to code at build time; at runtime everything shares one page. Sources: Enforce Module Boundaries
UX consistency: 5/5 (higher is better)
One app and one design system make a consistent experience the default. Sources: Micro Frontends
Tooling maturity: 4/5 (higher is better)
Monorepo tools ship boundary checks; some of them, such as Turborepo's, are still experimental. Sources: Enforce Module Boundaries, boundaries
Read about Modular monolith and monorepo →