When NOT to use them

Recognize the costs of micro frontends, complexity, performance, UX consistency and tooling overhead, and why small teams rarely benefit.

6 steps · ~5 min
How deep do you want to go?

Step 1 of 6

Every split has a price

Each micro frontend brings its own repository or package, pipeline, environment and hosting. That is more to build, monitor and keep up to date.

Cam Jackson calls this operational and governance complexity. His advice is to ask honestly whether your organization has the automation and maturity to run many small frontends without chaos.

Detailed

The cost grows with the number of pieces, not just the size of the app. Five micro frontends mean five pipelines to keep green, five sets of dependencies to update, and a shell that has to work with all of them.

Deep dive

Governance is the quieter cost. Someone has to decide how pieces talk to each other, which shared libraries exist and who maintains them. Jackson suggests a custodian for shared component libraries, and keeping communication between pieces minimal.

Next: More bytes, more requests
Step 2 of 6

More bytes, more requests

When each piece is built separately, it may bundle its own copy of the same libraries. The user then downloads them more than once. Jackson calls this the payload size problem.

Sharing libraries across pieces avoids the duplication, but it brings back coupling: teams have to agree on versions again. How much you pay, and where, depends on how the pieces are put together. Try three ways of building the same page below.

Demo E

Performance waterfall

The same page is built three ways, here with three team apps. With iframes, every app is a full page with its own HTML, its own copy of React and its own code: three apps mean three Reacts, 257 KB in all, and the page is interactive at about 750 ms, while first paint at 220 ms shows only the shell. With Module Federation, one shell and one shared React load first, then each remote adds a small entry file and a chunk: 149 KB, interactive at about 600 ms, with the slots empty at first paint. With server composition, the server fetches every fragment before it sends one composed page, so the content is already in the HTML at first paint, around 270 ms, and the browser only loads styles, React and small hydration scripts: 117 KB, interactive at about 470 ms, with the fragment fetches now happening on your servers. The model fetches fragments in parallel, as nginx SSI does; Fastly's ESI processes includes one after another, so there every fragment adds to the wait. The model and its numbers are illustrative, not a benchmark.

Every approach moves the cost somewhere.iframes download a framework per app, federation adds round trips per remote, and server composition moves the work to your servers. Measure the page your users actually load.
Detailed

Loading pieces at runtime can also mean extra round trips before the page is complete: first the shell, then each piece. Jackson notes that splitting can also speed up some first loads, since a page only needs its own code, and that the net effect has to be measured, not assumed.

Deep dive

Measure with real pages, not demos: total JavaScript per page, the number of requests before the main content shows, and how a slow or failing piece affects the rest. Setting a performance budget per team keeps duplication visible.

Next: Consistency gets harder
Step 3 of 6

Consistency gets harder

Users expect one product: the same buttons, the same spacing, the same behavior. When several teams release on their own schedules, small differences creep in.

CSS makes this harder because it is global by nature. Jackson notes that styles from one piece can leak into another unless teams isolate them on purpose.

Detailed

Jackson also warns about environment differences: a piece developed on its own may look and behave differently once it runs next to the others, especially with global styles. He recommends integrating often in an environment that looks like production.

Deep dive

A shared design system helps, but it is itself a shared dependency. Jackson’s advice is to share only presentational building blocks, not domain logic, and not to create the shared library too early.

Next: Small teams rarely benefit
Step 4 of 6

Small teams rarely benefit

Micro frontends remove waiting between teams. If there is only one team, there is little waiting to remove, but all the costs above still apply. As Natalia Venditto warns, adopting them without a real problem to solve can do more harm than good.

In our view, a single team, or a few teams that rarely block each other, should usually stay with one well-structured app. The decision check follows the same view: it never rates one team a reasonable fit, and for a few teams that rarely block each other it recommends one app or, at most, starting small with one pilot, unless a legacy app is being replaced piece by piece. It is also the choice this site makes for itself.

Detailed

Signs you might need micro frontends: several teams regularly wait on each other’s releases, parts of the app need different release speeds, or a legacy frontend has to be replaced piece by piece. Signs you don’t: one team, one release rhythm, and pain that comes from code structure rather than coordination.

Next: Try the cheaper options first
Step 5 of 6

Try the cheaper options first

Most of the ownership benefits can come from a modular monolith: one app and one deploy, split into modules that teams own, with rules that stop modules from reaching into each other. Natalia Venditto calls modularization a valid way to decouple a monolith, and argues it is more often than not the most suitable one.

Monorepo tools can check those rules for you. Nx can enforce module boundaries with tags and lint rules, and Turborepo has a boundaries check for packages. Both run in CI, so a forbidden import fails the build instead of reaching production.

Detailed

A modular monolith keeps one build and one release, so teams still share a release train. If that shared release becomes the bottleneck, the module boundaries you already have are a good place to start splitting, one piece at a time.

Deep dive

Jackson argues against integrating micro frontends at build time because it brings back lockstep releases. That criticism is about micro frontends that need independent deploys. If you don’t need independent deploys, one build is not a drawback but the simplest option.

Next: Recap and check
Step 6 of 6 · Recap

Recap and check

Three things to remember

  1. Every piece adds something to run.Each micro frontend brings its own pipeline, environment and hosting to build, monitor and keep up to date.
  2. Separate builds can mean more bytes.Pieces that bundle the same library make users download it more than once, and sharing it brings back version coupling.
  3. One team rarely benefits.In our view a single team should usually stay with one well-structured app, with module boundaries checked in CI.

Check yourself

0 of 2 answered · nothing is scored or saved
  1. 1
  2. 2
Question 1 of 2 · Pick one

Three micro frontends each bundle their own copy of the same UI library. What happens to the page?

  1. Nothing. The browser only downloads the library once.
  2. The user downloads the library up to three times.
Show answer

Answer: B. The user downloads the library up to three times.

  • A: Copies bundled into different files are different downloads. The browser can't tell they hold the same library.
  • B: Jackson calls this payload size. Sharing the library avoids it, but sharing brings back coordination between teams.
Nothing is scored or saved
Question 2 of 2 · Pick one

One team of six owns a frontend and wants clear boundaries between its features. What is the cheaper first step, in our view?

  1. Split into three micro frontends with their own pipelines.
  2. Keep one app, and enforce module boundaries with tooling.
Show answer

Answer: B. Keep one app, and enforce module boundaries with tooling.

  • A: That adds pipelines, environments and runtime composition, and the team still coordinates with itself. The cost buys little here.
  • B: Boundary rules checked in CI give clear ownership inside one app, with one build and one deploy.
Nothing is scored or saved