# Compare approaches

_Every rating is 1–5 for a typical team. Ratings are editorial judgement, each with a reason and a source on the approach's page._

| Approach | Team independence | Runtime performance | Complexity | SSR / SEO support | Tech-agnostic | Isolation | UX consistency | Tooling maturity |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| Build-time packages | 2/5 | 5/5 | 1/5 | 5/5 | 1/5 | 1/5 | 5/5 | 5/5 |
| Module Federation | 4/5 | 3/5 | 4/5 | 3/5 | 2/5 | 2/5 | 4/5 | 4/5 |
| Native Federation / import maps | 4/5 | 3/5 | 3/5 | 3/5 | 2/5 | 2/5 | 4/5 | 3/5 |
| single-spa | 4/5 | 2/5 | 4/5 | 2/5 | 5/5 | 2/5 | 3/5 | 3/5 |
| Web Components | 3/5 | 3/5 | 3/5 | 2/5 | 4/5 | 4/5 | 3/5 | 4/5 |
| iframes | 5/5 | 1/5 | 2/5 | 2/5 | 5/5 | 5/5 | 1/5 | 5/5 |
| Server and edge composition | 4/5 | 4/5 | 4/5 | 5/5 | 5/5 | 3/5 | 3/5 | 3/5 |
| Modular monolith and monorepo | 2/5 | 5/5 | 2/5 | 5/5 | 1/5 | 1/5 | 5/5 | 4/5 |

## Criteria

- **Team independence** (higher is better): Can teams build and deploy without coordinating?
- **Runtime performance** (higher is better): Impact on bundle size, requests and time to interactive.
- **Complexity** (lower is simpler): Setup and ongoing operational cost.
- **SSR / SEO support** (higher is better): How well it works with server rendering.
- **Tech-agnostic** (higher is better): Can different frameworks coexist?
- **Isolation** (higher is better): Style, script and failure isolation.
- **UX consistency** (higher is better): How easy it is to keep a consistent experience.
- **Tooling maturity** (higher is better): Ecosystem, docs and community.

## Build-time packages

Each team publishes its feature as a versioned npm package. The shell installs those packages, builds once, and ships a single bundle.

- **Team independence: 2/5.** Teams publish packages on their own, but nothing reaches users until the shell rebuilds and releases.
- **Runtime performance: 5/5.** One build produces one bundle, with shared dependencies deduplicated when the packages accept the same versions.
- **Complexity: 1/5.** Only packages and a normal build; there is no runtime loader to run.
- **SSR / SEO support: 5/5.** The result is one ordinary app, so any server rendering setup works as usual.
- **Tech-agnostic: 1/5.** Packages are compiled into the shell, so they share its framework and version.
- **Isolation: 1/5.** All code runs in one bundle and one page, so styles, globals and errors are shared.
- **UX consistency: 5/5.** One app with one design system makes a consistent experience the default.
- **Tooling maturity: 5/5.** Uses the standard package registry and build tooling every frontend team already has.

Full page: https://microfrontends.dev/approaches/build-time-packages

## Module Federation

Each team builds and deploys its own bundle. The shell loads those bundles at runtime and can share common dependencies, such as React, as a single copy.

- **Team independence: 4/5.** Each remote is a separate build that deploys on its own; the shell loads whatever is deployed at runtime.
- **Runtime performance: 3/5.** Each remote adds requests when it loads, while shared singletons avoid downloading the same library twice.
- **Complexity: 4/5.** You negotiate shared versions, manage remote URLs per environment, and handle remotes that fail to load.
- **SSR / SEO support: 3/5.** Server rendering is possible but needs extra setup beyond the client-side loading the docs describe.
- **Tech-agnostic: 2/5.** Mixing frameworks is technically possible, but sharing works best when every build uses the same framework.
- **Isolation: 2/5.** Remotes run in the same page and share globals, styles and the share scope.
- **UX consistency: 4/5.** Remotes render into one page and can share a design system as a shared dependency.
- **Tooling maturity: 4/5.** Built into webpack and supported by Rspack and a Vite plugin, with a dedicated project that adds a runtime, manifest and devtools.

Full page: https://microfrontends.dev/approaches/module-federation

## Native Federation / import maps

Each team builds its app into plain ES modules. An import map tells the browser where every remote and shared library lives, so the shell loads them at runtime without a bundler-specific loader.

- **Team independence: 4/5.** Each remote builds and deploys on its own, and the shell finds it through the manifest at runtime.
- **Runtime performance: 3/5.** Each remote adds module requests when it loads, while shared libraries resolve to one copy through the import map.
- **Complexity: 3/5.** Schematics set up hosts and remotes, but shared versions, manifests per environment and failing remotes are still yours to handle.
- **SSR / SEO support: 3/5.** The Angular adapter supports server rendering and hydration, with setup beyond a client-only host.
- **Tech-agnostic: 2/5.** The core is framework-agnostic, but sharing works best when every remote uses the same framework, and most tooling is Angular's.
- **Isolation: 2/5.** Remotes run as modules in the same page and share globals and styles.
- **UX consistency: 4/5.** Remotes render into one page and can share a design system as a shared library.
- **Tooling maturity: 3/5.** Maintained documentation, schematics and adapters, with a smaller ecosystem than Module Federation outside Angular.

Full page: https://microfrontends.dev/approaches/native-federation-import-maps

## single-spa

A small root config registers each application with the routes it owns, then mounts and unmounts it, even when the applications use different frameworks.

- **Team independence: 4/5.** Each application is loaded by the root config from its own build, so it can deploy separately.
- **Runtime performance: 2/5.** Several frameworks and their lifecycles on one page can add up to a lot of JavaScript.
- **Complexity: 4/5.** You own the root config, each application's lifecycle functions, routing and shared libraries.
- **SSR / SEO support: 2/5.** Server rendering relies on the optional layout engine and needs extra setup.
- **Tech-agnostic: 5/5.** Designed to run applications in different frameworks on one page.
- **Isolation: 2/5.** Applications share one page, so styles and globals can collide unless teams scope them.
- **UX consistency: 3/5.** Different frameworks make a shared design system harder to apply everywhere.
- **Tooling maturity: 3/5.** Established documentation, project generator and framework helpers, but no stable release since September 2024.

Full page: https://microfrontends.dev/approaches/single-spa

## Web Components

Each team ships its part as a custom element such as <team-b-cart>. The tag name, attributes and events are the contract, and Shadow DOM can keep each team's styles inside its element.

- **Team independence: 3/5.** 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.
- **Runtime performance: 3/5.** Each team's script is another request, and teams that each bundle a framework ship it more than once.
- **Complexity: 3/5.** The element API is small, but loading scripts, versioning tags and passing rich data are left to you.
- **SSR / SEO support: 2/5.** Elements usually render in the browser; declarative Shadow DOM allows server output but needs support from each team's tooling.
- **Tech-agnostic: 4/5.** Any framework can render or wrap a custom element, though frameworks differ in how they pass properties and handle events.
- **Isolation: 4/5.** 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.
- **UX consistency: 3/5.** 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.
- **Tooling maturity: 4/5.** Supported natively by browsers and well documented, with libraries available to cut boilerplate.

Full page: https://microfrontends.dev/approaches/web-components

## iframes

Each team's app is a separate page shown in a frame. Nothing leaks in or out, and nothing is shared, including the cost.

- **Team independence: 5/5.** Every frame is a separate app, served and deployed by its own team.
- **Runtime performance: 1/5.** Each frame loads its own document and resources and needs extra memory.
- **Complexity: 2/5.** Embedding is easy; sizing, routing and messaging between frames are the hard parts.
- **SSR / SEO support: 2/5.** 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.
- **Tech-agnostic: 5/5.** Anything that can render a web page can be framed.
- **Isolation: 5/5.** 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.
- **UX consistency: 1/5.** Integrating parts across frames is difficult, and responsive layout and deep links get harder.
- **Tooling maturity: 5/5.** Built into every browser, with no framework or build tool needed.

Full page: https://microfrontends.dev/approaches/iframes

## Server and edge composition

Each team serves HTML fragments from its own service. A server or CDN edge stitches them into one page before it reaches the browser, so visitors and crawlers get complete HTML on the first response.

- **Team independence: 4/5.** Each team deploys the service that renders its fragment, and the composer includes whatever it currently serves.
- **Runtime performance: 4/5.** The browser gets one complete page without client-side assembly, but every fragment fetch adds to the server's response time.
- **Complexity: 4/5.** You run and monitor a composing layer, handle timeouts and fallbacks, and still coordinate client-side scripts.
- **SSR / SEO support: 5/5.** Composition happens on the server or edge, so the first response is already complete HTML.
- **Tech-agnostic: 5/5.** The composer only sees HTML, so each team can render its fragment with any server technology.
- **Isolation: 3/5.** A failing fragment can be replaced by fallback content, but once assembled, fragments share one page, its styles and its scripts.
- **UX consistency: 3/5.** Fragments land in one page, but each team renders its own markup, so a consistent look depends on a shared design system.
- **Tooling maturity: 3/5.** SSI and ESI are long established and supported by common servers and CDNs, but support for ESI features varies by vendor.

Full page: https://microfrontends.dev/approaches/server-and-edge-composition

## Modular monolith and monorepo

One app and one deploy, split into team-owned modules. Boundary rules checked in CI keep teams out of each other's code, with most of the ownership benefits and little of the runtime cost.

- **Team independence: 2/5.** Teams own their modules, but everything still ships in one release.
- **Runtime performance: 5/5.** One app, built once, with no runtime composition cost.
- **Complexity: 2/5.** A normal app plus boundary rules to define and keep in CI.
- **SSR / SEO support: 5/5.** It is one ordinary app, so any server rendering setup works as usual.
- **Tech-agnostic: 1/5.** One build means one framework for the whole app.
- **Isolation: 1/5.** Boundaries apply to code at build time; at runtime everything shares one page.
- **UX consistency: 5/5.** One app and one design system make a consistent experience the default.
- **Tooling maturity: 4/5.** Monorepo tools ship boundary checks; some of them, such as Turborepo's, are still experimental.

Full page: https://microfrontends.dev/approaches/alternatives

Source: https://microfrontends.dev/compare