Skip to main content
What Are Micro Frontends?

What Are Micro Frontends?

July 25, 2025

Ashish Gogula

Imagine you're building a house with your friends.
One friend paints the walls. Another installs the furniture. Someone else handles the lighting.

You’re all working in parallel, not stepping on each other's toes — and when you're done, you combine it all into one beautiful, functional home.

That’s exactly the idea behind Micro Frontends.

But hey — this isn’t just a quick-read post. We’re breaking down a big topic into 6 simple but packed chapters. So:

Grab a coffee, put your phone on silent, and stay focused —
because by the end of this, you’ll go from "what is this?" to "I got this!"

Let’s dive in 👇

Section 1: So... What Are Micro Frontends?

Micro frontends are a way of breaking a big frontend app (like a giant React SPA) into smaller, independent pieces — each owned by a different team, developed and deployed separately, but working together in the browser.

Think of it like microservices, but for the frontend.

Instead of One monolithic React app

You now have:

  • A product page written in React
  • A cart widget powered by Vue
  • A search bar written in plain JS

All stitched together seamlessly.

But… Why Go Through All That Trouble?

Here’s the deal — as your app grows, things get messy:

  • Merge conflicts become common
  • Build times increase
  • One bad commit can break the whole app
  • Teams get blocked on each other

Micro frontends solve this by giving teams autonomy:

  • Each team owns their part of the UI
  • They choose their own tech (React? Vue? Svelte? Go wild)
  • They deploy independently (no waiting on others!)

It’s like breaking a big puzzle into smaller pieces — each managed separately, but snapping together into a whole.

Real-World Analogy: Netflix, IKEA, Amazon

Ever wondered how Amazon manages cart, recommendations, and account pages without breaking a sweat?

Each of those is its own micro frontend — maintained by separate teams, with their own roadmaps, release cycles, and even tech stacks.

TL;DR

Micro frontends = Split your big frontend into smaller, independently managed apps that come together in the browser.

Section 2 - Core Concepts — From Beginner to Intermediate

Okay, now that you know what micro frontends are, let’s dig a little deeper.

Still keeping it simple — no buzzwords or complicated acronyms (yet).

1. Each Micro Frontend Is a Mini App

Think of each part of your UI — like the navbar, cart, or user profile — as a standalone app. It can:

  • Have its own codebase
  • Use its own framework (React, Vue, Svelte, whatever)
  • Be deployed separately

Each micro frontend is like a Lego block 🧱 — small, powerful, and pluggable.

2. They Run Together… in One App

So how do these “mini apps” actually combine?

You stitch them together using a technique like:

  • Module Federation (Webpack 5) — the most popular one today
  • iframes (not cool, but sometimes useful)
  • build-time composition (monorepos, Lerna, Turborepo)
  • runtime composition (like a shell app loading remote apps on the fly)

The shell or host app brings all the pieces together.

3. Teams Work Independently

This is one of the main selling points of micro frontends.

Each team gets to:

  • Work at their own pace
  • Choose their stack
  • Deploy without waiting for others
  • Own their domain end-to-end (like checkout, search, etc.)
No more “who broke the build again??” moments 😅

4. You Can Even Mix Frameworks!

Yup. You could have:

  • Header in React
  • Sidebar in Vue
  • Footer in Svelte

And it all works together — as long as you plan the integration well (and don’t go too wild).

5. Communication Between Apps Matters

Since these are separate apps, sharing data gets tricky.

You might need:

  • A shared event bus (like a pub/sub system)
  • Props passed from the host
  • Shared global state via something like Redux or Zustand (careful with bundle size!)

TL;DR

  • Each part of your UI becomes its own app
  • You load them together in the browser
  • Teams ship features independently
  • The browser becomes your new “backend”

Section 3 -How Micro Frontends Work

We’re gonna talk about Module Federation — the secret sauce that lets multiple frontend apps work together like magic. 🪄

What Is Module Federation?

Imagine you built a header for your app… but instead of compiling and copying it into another app, you just say:

“Hey App B, here’s my header. You can use it at runtime.”

Boom. Now your header is shared live — no rebuilding needed.

That’s Module Federation, introduced in Webpack 5. It lets you:

  • Expose parts of your app (like a component or a route)
  • Consume parts from other apps
  • Run everything independently, but together

It’s like importing components across different repositories — at runtime.

Host vs Remotes

You’ll hear these terms a lot, so let’s break it down:

  • Host: The main app that loads others
  • Remote: The app that’s being loaded (like NavbarApp, CheckoutApp, etc.)

Visualize It Like:

Host App (main shell)
├── loads Navbar from NavbarApp
├── loads ProductGrid from ProductApp
└── loads Cart from CartApp

Each remote app can be:

  • Developed separately
  • Deployed to a different domain or URL
  • Versioned and updated on its own

How Does the Code Sharing Actually Work?

Let’s say you’re using React in both Host and Remote. Instead of bundling React twice (😩), Module Federation can share dependencies like this:

shared: {
  react: { singleton: true },
  "react-dom": { singleton: true },
}

Meaning:

“Hey, use my React. Don’t bring your own.”

Result: Smaller bundles + fewer conflicts.

Dynamic Imports in Action

Your host app can dynamically load parts like:

const Navbar = React.lazy(() => import("navbarApp/Navbar"));

And just like that — poof 💨 — the Navbar is loaded from a completely different app.

What Could Go Wrong?

Let’s keep it real. Module Federation is cool but not magic:

  • Version mismatches? 💥 Boom.
  • Slow networks? 💀 Your lazy-loaded app might delay rendering.
  • Auth issues? 🧑‍✈️ Separate apps = separate security contexts.

But with good planning, it works beautifully.

TL;DR

  • Module Federation lets you import code from other apps at runtime
  • You share components, dependencies, and logic — live
  • One team’s updates don’t block another
  • The shell app (host) decides how everything fits together

Section 4:Real-World Micro Frontend Use Cases

(a.k.a. "Where the Cool Kids Actually Use It")

Okay, okay — theory is nice. But let’s talk real apps, real teams, real chaos.

E-commerce Platforms

Imagine you’re Amazon (or just pretending to be).

You’ve got:

  • A product listing team
  • A cart team
  • A checkout team
  • A recommendations team

Do you want everyone working on one giant frontend repo?
No way. That’s a merge-conflict nightmare. 😵‍💫

So instead:

  • Each team builds their part as a standalone app
  • They deploy independently
  • The main shell loads their piece using Module Federation

Micro frontends to the rescue.


🏦 Banking Dashboards

Banking apps are the definition of “slow-moving monoliths.” 🐢
They have dozens of internal tools and pages — but all stitched together in one massive app.

With micro frontends:

  • The loans team can ship updates without asking the transactions team
  • Legacy pages can slowly migrate to React/Next.js without breaking stuff
  • Teams get freedom without chaos

Design Systems as Micro Frontends

Got a design system or component library?

Instead of publishing to npm and waiting for everyone to upgrade...
You can expose it as a live remote app.

That way, the latest version is always available, and everyone stays consistent — like good little UI citizens.

Real Examples from Big Players

  • Spotify uses micro frontends for its desktop and web player
  • DAZN (sports streaming) uses it for modular content pages
  • IKEA adopted micro frontends to separate cart, product view, and search

Even Microsoft used similar architecture in Office365.

TL;DR

  • Micro frontends shine when multiple teams work on one product
  • They offer independent deploys without full rebuilds
  • Great for large orgs, slow legacy apps, or apps with frequent UI changes
  • They're already powering some of the biggest apps you use daily

Section 5: Pros, Cons & Should You Use Micro Frontends?

Why Micro Frontends Can Be Awesome

1. Independent Teams, Happy Devs

Each team owns their feature, tech stack, and deployment cycle.

“You build it, you ship it, you own it.”
No more waiting for the monolith build to finish just to change a button.

2. Tech Stack Freedom

One team wants React? Another wants Vue? Go for it.
Micro frontends allow this level of chaos — responsibly.

Real-world: One team at IKEA uses vanilla JS, another uses React — all in the same app.

3. Faster Releases, Smaller Risk

Shipping a bug in the “Search” micro app won’t break the “Cart” micro app.
It’s like damage control… built into your architecture.

4. Incremental Adoption

Still stuck with a legacy app? You can slowly refactor just parts of it into micro frontends.
No need for a full rewrite from scratch (aka the "rewrite and regret" trap).

Why Micro Frontends Might Punch You in the Face

1. Initial Setup = 😵‍💫

Webpack configs. Shared dependencies. CI/CD pipelines.
It’s not plug-and-play… especially the first time around.

“You’ll feel like you’re building a spaceship just to render a button.”

2. Performance Overhead

Each micro app might load its own JS bundles, duplicated libraries, etc.
Unless you carefully manage shared dependencies — you’ll suffer.

3. UX Consistency Issues

Without a strong design system, each micro app might look or behave slightly differently.
The result? Franken-app.

“Like five chefs cooking one dish — could be a masterpiece, or a mess.”

4. Communication Overhead

More moving parts = more talking.
Version mismatches, deployment coordination, shared contracts… all require planning.

Should You Use Micro Frontends?

Here’s a brutally honest rule of thumb:

Use micro frontends if:

  • You’re working in a large organization with multiple independent teams
    → Micro frontends will help you scale without stepping on each other’s toes.
  • You’re migrating a legacy monolith
    → Micro frontends can help modernize piece by piece — like upgrading a spaceship mid-flight 🚀.

🟡 Maybe consider them if:

  • You have a mid-sized app and a fast-moving team
    → Just weigh the setup cost vs. the benefit. Sometimes it’s overkill.

🔴 Avoid micro frontends if:

  • You’re building a small app with 1–2 devs
    → Keep it simple, keep it fast. Micro frontends will only slow you down.

TL;DR

  • Micro frontends bring autonomy, modularity, and resilience to large teams
  • But they also add complexity, especially early on
  • Use them only when your team structure, product scale, or release needs justify the overhead

Section 6

So... How Do You Actually Build a Micro Frontend?

Here’s a dead-simple, beginner-friendly roadmap to go from zero to micro frontend hero 🦸

There are 3 common approaches:

1. Iframe Embeds (Avoid unless desperate 👎)

  • Each app lives on its own domain, embedded via <iframe>
  • Easy to start, but bad for UX, routing, and shared state
    Use only if your apps are completely isolated and rarely need to talk.

2. Build-Time Integration (Coupled but simple 🚧)

  • Teams build separate apps, but one shell app imports and stitches them together at build time
  • All micro frontends are bundled into one final deployable

✅ Easier to start with tools like Nx
❌ No independent deployments

3. Run-Time Integration with Module Federation (🥇 Most powerful)

  • Each micro app ships independently
  • They’re loaded at runtime using Webpack Module Federation
  • You get true autonomy, shared components, and live updates!
🛠️ Frameworks that make it easier:

Step 2: Build the Shell + Micro Apps

  • Shell App = the container. Handles routing, layout, shared state
  • Micro Apps = individual features/modules (like Cart, ProductPage, Profile)

Each micro app gets its own:

  • Repo (or sub-package in a monorepo)
  • CI/CD pipeline
  • Versioning
Example folder structure (monorepo):
/apps
  /shell
  /product
  /cart
  /checkout

Step 3: Manage Shared State & Design

To prevent chaos:

  • Use a design system (Storybook, Tailwind, etc)
  • Use a global store (Zustand, Redux, etc) only when needed
  • Keep communication between micro apps minimal — pass props via shell, use pub/sub if necessary

Step 4: Deploy & Integrate

Each micro app gets:

  • Its own build (hosted on S3, Vercel, etc)
  • Loaded by the shell using remoteEntry.js

And just like that — BOOM 💥 — you’ve got micro frontends!

Bonus: Resources to Learn More

Final Thoughts

Micro frontends aren’t a silver bullet — they’re a scaling strategy.

Use them when your frontend starts acting like a backend: multiple teams, big features, and fast releases.
But if your app is small — keep it simple.

“With great power comes great... webpack configs.” 😅



☕ Like this blog?

If this helped you survive the chaos of micro frontends or just made you chuckle at the pain, consider buying me a coffee:

coff.ee/ashishgogula (opens in new tab)

(I promise not to spend it all on Webpack plugins.)
Read more blogsSend a little caffeine love ☕💕 (opens in new tab)