Three teams each deploy twice a week: 8 hours a week lost to waiting against a split that costs 10 hours, a balanced trade, not a clear win. Below, micro-frontend use fell from 75.4% of State of Frontend respondents in 2022 to 23.6% in 2024.

Are micro frontends worth the complexity? Count your teams and deploys first

If you lead several teams on one frontend, the split is a bet on hours. Count who waits on whose release, price what the split adds each week, and keep the monolith when the waiting is small.

Are micro frontends worth the complexity for your team?#

Micro frontends are worth the complexity only when several teams ship one frontend and lose real time every week waiting on each other's releases. In the illustrative model below, three teams that each deploy twice a week land close to break-even. However, one team never gains at any cadence, since it has no peer to wait on.

The single-spa frequently asked questions (FAQ) page makes the same call about its own tool. For a small project or a small team, "we would recommend you stick with a monolith" until scaling gets hard. Because that advice comes from the project that builds a micro frontend router, it carries weight.

Net h/wkGainCost
is the weekly hours of release waiting the split removes.
is the weekly hours a shell, contract tests and rollback checks add.

What does the split buy, and what does it cost every week?#

The split buys each team the right to deploy without waiting on the others, and it charges a shell, contract tests and rollback checks every week. In a shared release, each deploy waits on the other teams in the train. As a result, the loss grows with every peer and every deploy.

The cost has three parts. First, a fixed platform cost covers the shell, the shared dependencies and the pipeline. Second, each team pays for contract tests and version alignment. Third, each deploy needs a compatibility check, because rollback is no longer atomic.

For example, say three teams each deploy twice a week, and each shared deploy loses 2 hours per peer. In this illustrative case, that is 2 deploys times 2 peers times 2 hours, or 8 hours a week. Then say the split costs 4 platform hours, 1.5 hours per team and a quarter hour per deploy. Those illustrative costs add up to 4 plus 4.5 plus 1.5, or 10 hours. So the gain covers about four fifths of the cost: a balanced trade, not a clear win.

Try it
Team count
1 per week (fast monolith) to 10+ per week (high-velocity teams)

Balanced trade

Coordination cost roughly matches release velocity gain.

Coordination overhead: 10 hours/week

Release velocity gain: 8 hours/week

Ratio: 0.8x → Roughly balanced

Full comparison table
TeamsDeploys/wkCoordination (hr)Release Gain (hr)Verdict
115.80Monolith is faster
1260Monolith is faster
146.50Monolith is faster
319.34Monolith is faster
32108Balanced trade
3411.516Balanced trade
5112.88Monolith is faster
521416Balanced trade
5416.532Micro frontends justify the cost
10121.518Balanced trade
1022436Balanced trade
1042972Micro frontends justify the cost

This calculator uses an illustrative coordination-cost model calibrated to Nx and Module Federation operational patterns. Your team's actual overhead depends on testing discipline, shared-code governance, and deployment automation. Adjust this model to match your own deployment history.

Change the team count and deploys per week to see weekly hours of release waiting removed against coordination hours. An illustrative model with stated constants. Modelled, not measured.

With five teams at three deploys a week, the same illustrative model gives 24 hours gained against about 15 of overhead. With one team, the gain is zero at any cadence. Swap in your own hours first.

Which deployment-scale signals justify micro frontends?#

The signals are organisational: teams blocked on each other's releases, deploy windows, and builds Vercel flags at over 5 minutes, per its guidance read in November 2026. Vercel's chapter on when the pattern makes sense lists five symptoms. A long build means too much code compiles for every change. Blocked teams mean the shared codebase creates coordination overhead. A "don't touch that file" habit shows fear of breaking unrelated features. Deploy windows mean you can only ship at set times. Finally, slow local start-up is the fifth.

Vercel's two build-time lines, in its November 2026 guidance, bracket the choice: over 5 minutes is a symptom, and under 3 means faster tooling first.

Show data table
Build-time lines in minutes, Vercel Academy, When Microfrontends, read November 2026.
ItemValue
build time that signals too much code compiling per change5 minutes
build time under which faster tooling comes first3 minutes

Over 5 minutes is a symptom; under 3 minutes, faster tooling comes first.

Vercel's build-time linesBuild-time lines in minutes, Vercel Academy, When Microfrontends, read November 2026.Vercel, When Microfrontends (Vercel Academy)

Then measure before you decide. The metrics guide from DevOps Research and Assessment (DORA) defines deployment frequency as deployments over a period. It defines change lead time as the time from commit to production. For instance, if one team's merged work sits undeployed while another finishes, lead time shows the queue. However, DORA warns against turning a metric into a goal, so read these as symptoms, not targets.

What do shared dependencies cost after the split?#

A change to a shared library forces every app that consumes it to redeploy, as Nx documents, so shared dependencies quietly bring the release train back. Module Federation is the runtime loading of separately built code. In the words of the Nx guide, "When you change a shared library, Module Federation forces every app that consumes it to redeploy." So a design system or a framework upgrade still moves in step.

Since only one copy of a library can win at runtime, someone has to pick it. The webpack docs give the rule: "a consumer gets the highest version in the scope that satisfies its range". Meanwhile, the single-spa FAQ recommends an import map, a browser lookup table for module URLs, so each library is defined once.

Either way, the cost lands on people. For instance, if five teams share one component library, every breaking change becomes a five-team release. As a result, the per-team cost never falls to zero. That is why team autonomy and governance for micro frontends matters as much as the split.

One shared-library change fans outOne shared-library change, every consumer redeploys: the Nx Module Federation guide, read November 2026.

What does the drop from 75.4% to 23.6% actually tell you?#

In The Software House's State of Frontend survey, micro-frontend use fell from 75.4% of respondents in 2022 to 23.6% in 2024, read in November 2026. The drop is a smaller share of each edition's respondents, not a count of teams that left.

Share of respondents who used micro frontendsdifferent samples each edition

75.4%

2022 edition

23.6%

2024 edition

The drop is a smaller share of each edition's respondents, not a count of teams that left.

Share of respondents who used micro frontends (% of each edition's respondents; each edition surveys a different set of respondents)
Option% of each edition's respondents; each edition surveys a different set of respondents
2022 edition75.4%
2024 edition23.6%

Source: The Software House, State of Frontend 2022 and 2024

Because the survey asks a new sample each edition, the two figures describe different groups. Luca Mezzalira, a solutions architect at Amazon Web Services (AWS), wrote its micro frontends commentary. "Some companies that didn't truly need micro-frontends attempted to implement them, partly explaining the decline," he writes. He adds that many companies found the pattern can "demand organizational and cultural changes, which they weren't ready for". He also points to more investment in server-side rendering (SSR) and static-site generation (SSG), which share many of the same ideas.

In the 2024 edition, fewer than one respondent in four had used the pattern in the past year.

Show data table
Used micro frontends in the past year, The Software House, State of Frontend 2024.
SegmentValue (%)Share
Yes23.623.6%
No76.476.4%

In the 2024 edition, fewer than one respondent in four had used the pattern in the past year.

Used in the past year, 2024Used micro frontends in the past year, The Software House, State of Frontend 2024.The Software House, State of Frontend 2024

In short, the figure confirms the test rather than replacing it. The pattern narrowed toward the organisations whose release friction pays for it.

When are micro frontends the wrong fit, and what fits instead?#

Stay monolithic when one team ships the frontend or every screen shares one flow; single-spa's own FAQ tells a small team to stick with a monolith. Vercel's November 2026 guidance names five wrong cases. For fewer than 5 developers, "The coordination overhead isn't worth it." For builds under 3 minutes, try faster tooling first.

The other three are a tightly coupled user experience (UX), a single domain of expertise, and "we might scale someday". Vercel also names the overhead: "duplicated auth checks, more complex debugging, additional configuration."

Each case has a better tool. For example, a checkout that runs from cart to payment in one session is tightly coupled. Splitting it puts a runtime contract at every step, so keep one app with module boundaries. When everyone works on everything, there is no team line to cut along. Instead, keep one codebase and one release. For the someday case, write down the signal that would change the answer and check it each quarter. The monolith is a decision you keep making, not a failure.

Five cases where Vercel's guidance, read November 2026, says the split is wrong, with the tool that fits instead. Source: Vercel, When Microfrontends (Vercel Academy); single-spa FAQ.

Wrong caseWhat fits instead
Fewer than 5 developersStay monolithic: "The coordination overhead isn't worth it."
Builds under 3 minutesTry faster tooling first
A tightly coupled user experience (UX)Keep one app with module boundaries
A single domain of expertiseKeep one codebase and one release
"We might scale someday"Write down the signal that would change the answer and check it each quarter

What should you try before splitting the frontend?#

Try module boundaries inside one app, affected-only builds and faster build tooling first, because each removes a signal without adding a runtime join. First, give each team a folder it owns, plus a lint rule that blocks imports across folders. That answers the "don't touch that file" habit without a second deploy.

Second, rebuild only what changed. In the Nx guide, the affected command computes the set of apps a change touches, then rebuilds and retests only those. Third, make the build faster: Vercel's November 2026 guidance says that under 3 minutes, try its Turbopack bundler first.

  1. Module boundaries

    Give each team a folder it owns, plus a lint rule that blocks imports across folders.

  2. Affected-only builds

    Rebuild and retest only the apps a change touches, as the Nx affected command does.

  3. Faster build tooling

    Under 3 minutes, try Turbopack first, per Vercel's November 2026 guidance.

Then measure again after a quarter. If the signals are gone, you saved the split's weekly cost. Also, the micro frontends vs monolith choice mirrors the backend one, as microservices vs monolith sets out.

If the signals say split, where do you start?#

Start from the integration options and setup in the Module Federation guide, since Module Federation was the solution 51.8% of respondents used in 2024. The Software House's State of Frontend 2024 survey puts single-spa second, at 35.5%.

Show data table
Micro frontend solutions used, share of respondents, The Software House, State of Frontend 2024.
ItemValue
Webpack 5 Module Federation51.8%
Single SPA35.5%
Open Components6.3%
SystemJS6.1%
Bit5.9%
Qiankun1.8%
Luigi1.5%
Piral1.3%

Module Federation at 51.8% and single-spa at 35.5% lead every other solution.

Micro frontend solutions used, 2024Micro frontend solutions used, share of respondents, The Software House, State of Frontend 2024.The Software House, State of Frontend 2024

The hub guide owns the next decision. It covers what micro frontends are and where Module Federation fits. It then compares each integration option and shows how to build with Module Federation. Also, each remote adds work to the first page load, which the Core Web Vitals cost of Module Federation measures. A team whose app runs on Next.js faces a narrower choice in 2026, so read how to split a Next.js app in 2026 for what the App Router supports.

Where to go from here#

Run the test on your own teams, then read the guide that fits your answer: the hub to split, the strangler pattern to migrate, governance to run it. To split, open the micro frontends and Module Federation guide. To move off a legacy app a route at a time, read the incremental strangler migration. Once the split is live, team autonomy and governance covers the rules.

For a team to build the split with you, see custom software development. For the per-team pipelines and rollback that independent deploys need, see DevOps and continuous integration and delivery (CI/CD). Still, the single-spa FAQ and Vercel's guide are enough on their own to run the test.

Questions this post answers

Are micro frontends worth the complexity for a small team?
For a team of fewer than 5 developers, Vercel's guidance read in November 2026 says the split is not worth it. In its words, "The coordination overhead isn't worth it." The single-spa FAQ also tells a small team to stick with a monolith.
How many teams do you need before micro frontends pay off?
There is no fixed count, because the answer depends on how often each team deploys. In the illustrative model above, three teams at two deploys a week sit near break-even. Five teams at three deploys a week clear the cost.
Did teams abandon micro frontends between 2022 and 2024?
The data does not show that. The Software House's State of Frontend survey found 75.4% of respondents used them in 2022 and 23.6% in 2024, but each edition surveys different respondents. Its commentary links part of the decline to companies that never needed the pattern.

Keep reading