Problems they solve

Identify the real drivers for micro frontends, team autonomy, independent deploys, scaling across many teams and incremental migration, and tell them apart from problems micro frontends don't fix.

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

Step 1 of 6

The real driver is people

Micro frontends are mostly about teams, not code. When several teams work on one frontend, they keep stepping on each other: the same build, the same release, the same files.

The idea is to let each team own a part of the product completely, so it can decide and ship without waiting for others. Cam Jackson calls these autonomous teams, each owning a slice of the product from idea to production.

Natalia Venditto makes the same point: splitting a frontend mainly solves organizational problems, such as teams working on features with different development cycles. Her advice is to ask whether you really have those problems before choosing micro frontends.

Detailed

Jackson recommends slicing teams around what users see, often a whole page or feature, rather than around technical layers. A team that owns “checkout” can change its page end to end; a team that owns “styling” has to coordinate with everyone.

Deep dive

Geers adds that each team should be able to choose and upgrade its own stack without coordinating with other teams. In practice many organizations keep one framework for consistency and hiring, and use the separation mainly for ownership and release independence.

Next: Shipping without waiting
Step 2 of 6

Shipping without waiting

In one shared frontend, every change rides in the same release. If one team’s work is not ready, others wait, or the release goes out with a half-finished feature hidden behind a flag.

With micro frontends, each piece has its own pipeline to production. Jackson’s point is that a team’s release should not depend on the state of anyone else’s codebase.

The demo below plays one week of finished work both ways: on a shared release train, and with each team deploying on its own.

Demo C

Independent deploys

Two teams finish three changes in one week: Team A's v2 on Monday, Team B's fix v1.1 on Wednesday and Team A's v3 on Thursday. With a release train, everything ships together on Friday, so finished work waits: v2 for 4 days, the fix for 2 and v3 for 1, 7 team-days in all, for one release. With independent deploys, each change goes live the day it is ready: three releases, no waiting, and Team B never has to coordinate with Team A. The days are illustrative.

Same work, 7 team-days sooner.Independent deploys don't make teams faster: they stop finished work from waiting for everyone else. In our view, if your teams rarely wait, this benefit is small.
Detailed

This only holds when the pieces are composed at runtime or on the server. If each piece is a package bundled into the shell at build time, the shell still has to rebuild and release for any change to reach users, and teams are back to sharing a release.

Deep dive

Independent deploys move work elsewhere: each team now needs its own pipeline, environments and a way to roll back its piece without breaking the page.

Next: Smaller codebases
Step 3 of 6

Smaller codebases

Each micro frontend is a smaller codebase than the whole app. A team can understand all of its own code, and it is harder to reach into another team’s code by accident.

Jackson notes a side effect: sharing domain models between micro frontends becomes harder on purpose, which pushes teams toward clearer, more explicit contracts.

Detailed

Smaller does not mean simpler overall. The total amount of code, pipelines and infrastructure usually grows. What shrinks is what each team has to hold in its head.

Next: Changing an old frontend piece by piece
Step 4 of 6

Changing an old frontend piece by piece

Rewriting a large legacy frontend in one go is risky and slow. Micro frontends offer another path: replace one part at a time, while the rest keeps running.

Jackson describes this as an incremental upgrade: a new piece built with new tools sits next to the old ones, and the old app shrinks piece by piece instead of everything stopping for one big upgrade.

Try both plans on the same shop and compare when users first get something new.

Demo H

Strangler fig migration

A router sits in front of a legacy shop that serves /search, /product, /cart and /checkout. Route by route, the team rebuilds one route at a time, about two weeks each, and points the router at the new code as soon as it is ready: /search goes live at week 2, /product at week 4, /cart at week 6 and /checkout at week 8, while the legacy app keeps serving everything not yet moved. If a new route misbehaves, the router sends it back to legacy without a rebuild, and once nothing routes to legacy, the legacy app can be removed. A big-bang rewrite takes the same eight weeks, but nothing reaches users until all four routes switch at once at week 8. By then, route by route has had 12 route-weeks live, against none. The weeks are illustrative.

Migrate one route at a time, not all at once.Each route reaches users as soon as it is ready, and a bad one can be routed back. In our view, the first route you move is the experiment that tells you whether to move the rest.
Detailed

The same works for framework upgrades. One team can move its piece to a new framework version while others stay where they are, instead of the whole app upgrading on one date.

Deep dive

This is the strangler fig pattern applied to the frontend. Martin Fowler’s version of the idea: build the new system around the edges of the old one and let it grow, until the old system can be switched off.

Next: What they don’t solve
Step 5 of 6

What they don’t solve

Micro frontends are a fix for coordination between teams. In our view they are not a fix for:

  • Slow pages. Separately loaded pieces usually add requests and can duplicate libraries.
  • A messy codebase in one team. Splitting it adds deploys without removing the mess; better module boundaries are cheaper.
  • Unclear ownership. If nobody knows who owns what, splitting the code just moves the confusion.
Detailed

A quick test before adopting them: name the teams that would own each piece, and the waiting you expect to remove. If you can’t name more than one team, or there is no waiting, the next lesson is the one to read.

Next: Recap and check
Step 6 of 6 · Recap

Recap and check

Four things to remember

  1. The real driver is people.Micro frontends remove waiting between teams that share one frontend, not problems in the code itself.
  2. Each team ships without waiting.A finished change reaches users through its own pipeline, as long as the pieces are composed at runtime or on the server.
  3. Old frontends can be replaced piece by piece.New code takes over one part at a time while the legacy app keeps running, so users get something new sooner.
  4. They don’t fix slow pages, messy code or unclear ownership.Splitting adds deploys without removing those causes; in our view cheaper fixes come first.

Check yourself

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

Team B finishes a fix on Monday. In a shared frontend release, Team A's half-done feature blocks the Tuesday release. Which benefit of micro frontends targets this?

  1. Independent deployment
  2. Smaller bundles
  3. Better code quality
Show answer

Answer: A. Independent deployment

  • A: With its own pipeline, Team B's fix goes out when Team B is ready, whatever state Team A's code is in.
  • B: Micro frontends often make total download size larger, not smaller. The problem here is waiting on another team, not bytes.
  • C: Splitting can make accidental coupling harder, but nothing here is about quality. Team B is waiting on a shared release.
Nothing is scored or saved
Question 2 of 2 · Pick one

A single team of five has a slow, messy frontend. Which problem would micro frontends most likely solve for them?

  1. The slow page loads
  2. The messy code
  3. Probably neither
Show answer

Answer: C. Probably neither

  • A: Splitting into separately loaded pieces usually adds requests and can duplicate libraries. Performance work is a separate job.
  • B: One team splitting its own code into separately deployed apps adds pipelines and coordination without removing the mess. Better module boundaries are cheaper.
  • C: In our view, yes. Micro frontends solve coordination between teams. One team has little of that to remove, so it pays the costs without the main benefit.
Nothing is scored or saved