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.
| Criterion | npm packages | Module Federation | Native Federation | single-spa | Web Components | iframes | Server / edge | Modular monolith |
|---|---|---|---|---|---|---|---|---|
| Team independencehigher is better | 2/5 | 4/5 | 4/5 | 4/5 | 3/5 | 5/5Best | 4/5 | 2/5 |
| Runtime performancehigher is better | 5/5Best | 3/5 | 3/5 | 2/5 | 3/5 | 1/5 | 4/5 | 5/5Best |
| Complexitylower is simpler | 1/5Best | 4/5 | 3/5 | 4/5 | 3/5 | 2/5 | 4/5 | 2/5 |
| SSR / SEO supporthigher is better | 5/5Best | 3/5 | 3/5 | 2/5 | 2/5 | 2/5 | 5/5Best | 5/5Best |
| Tech-agnostichigher is better | 1/5 | 2/5 | 2/5 | 5/5Best | 4/5 | 5/5Best | 5/5Best | 1/5 |
| Isolationhigher is better | 1/5 | 2/5 | 2/5 | 2/5 | 4/5 | 5/5Best | 3/5 | 1/5 |
| UX consistencyhigher is better | 5/5Best | 4/5 | 4/5 | 3/5 | 3/5 | 1/5 | 3/5 | 5/5Best |
| Tooling maturityhigher is better | 5/5Best | 4/5 | 3/5 | 3/5 | 4/5 | 5/5Best | 3/5 | 4/5 |
Swipe to compare · 8 cardsTeam independence4/5Runtime performance3/5Complexity4/5SSR / SEO support3/5Tech-agnostic2/5Isolation2/5UX consistency4/5Tooling maturity4/5 Team independence4/5Runtime performance3/5Complexity3/5SSR / SEO support3/5Tech-agnostic2/5Isolation2/5UX consistency4/5Tooling maturity3/5 Team independence4/5Runtime performance2/5Complexity4/5SSR / SEO support2/5Tech-agnosticBest5/5Isolation2/5UX consistency3/5Tooling maturity3/5 Team independence3/5Runtime performance3/5Complexity3/5SSR / SEO support2/5Tech-agnostic4/5Isolation4/5UX consistency3/5Tooling maturity4/5 Team independenceBest5/5Runtime performance1/5Complexity2/5SSR / SEO support2/5Tech-agnosticBest5/5IsolationBest5/5UX consistency1/5Tooling maturityBest5/5 Team independence4/5Runtime performance4/5Complexity4/5SSR / SEO supportBest5/5Tech-agnosticBest5/5Isolation3/5UX consistency3/5Tooling maturity3/5 Team independence2/5Runtime performanceBest5/5Complexity2/5SSR / SEO supportBest5/5Tech-agnostic1/5Isolation1/5UX consistencyBest5/5Tooling maturity4/5
Team independence2/5Runtime performanceBest5/5ComplexityBest1/5SSR / SEO supportBest5/5Tech-agnostic1/5Isolation1/5UX consistencyBest5/5Tooling maturityBest5/5
Module Federation
DetailsNative Federation / import maps
Detailssingle-spa
DetailsWeb Components
Detailsiframes
DetailsServer and edge composition
DetailsModular monolith and monorepo
DetailsRatings 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
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
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
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
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
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
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
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