Module Federation at Scale with Zack Chapple & Nestor

🎧 New Señors @ Scale Episode

This week, I sat down with Zack Chapple, CEO and co-founder of Zephyr Cloud, and Nestor, the platform engineer building Zephyr Cloud, to go deep on what it actually takes to go from code to global scale in seconds. Zack's path started at a consulting company called Valor where SAP asked them to add module federation support to Angular — and the pain points they hit there became the seed for Zephyr. Nestor's microfrontend journey goes back almost a decade to Sencha.js / ext.js iframe-based composition, through TRPC open source contributions, into building the platform layer at Zephyr.

In this episode, we cover the analogy of module federation as Docker for the frontend, why Zephyr is the Kubernetes-plus on top, hot-swapping microfrontends in production via a Chrome extension, reverse tree shaking at the edge, federated MCPs, an open TC39 PR that could enable HMR for Node, and what it's like building a venture-backed startup with four kids in Atlanta.

⚙️ Main Takeaways

1. Module Federation is Docker for the frontend — Zephyr is the Kubernetes-plus

Zack's go-to analogy reframes the whole conversation for backend folks who don't yet know what microfrontends are.

• The evolution: Microservices arrived and chaos followed. Docker containerized the world. Kubernetes (and ECS) became the orchestration layer. The frontend went through the same cycle — iframes, then Singlespa, then module federation.
• The mapping: "Module federation, we affectionately call Docker for the frontend. And then Zephyr is like the Kubernetes plus in that analogy." — Zack
• The API similarity: What you expose, what you consume, what ports/endpoints you're on — module federation and Docker have surprisingly similar shapes.
• The problems Zephyr solves: Where am I deploying, how am I deploying, how do I change what I'm consuming across environments — all the orchestration questions Docker introduced and Kubernetes answered.

2. The earliest Zephyr looked nothing like today

A reminder that v1 is supposed to be ugly.

• Medusa, the predecessor: Next.js with MongoDB, on the cheapest cold-starting Mongo instance. Logging in took roughly 45 seconds.
• The first Zephyr cut: Nest with vanilla React. Still ugly. Pre-vibe-coding era.
• The current stack: Migrated to Hono on the backend and from MUI to Shadcn on the UI — "a huge win" per Zack. Less ugly, more flexibility.
• The Pied Piper analogy: "If you ever saw the TV show Silicon Valley and you remember Pied Piper, that's what we built. Extremely powerful — but usually we have to explain to people how to use it." — Zack

3. You don't need microfrontends to use Zephyr — you just need a bundler

The on-ramp is intentionally low.

• The hook: Zephyr hooks into the bundler itself. One line of code (with Zephyr inside your bundler config) and a Codemod handles the wiring.
• The Jordan Powell story: When Jordan was at X, he built splash pages for events and got tired of setting up CI/CD pipelines for sites that lived only a few days. Zephyr let him build on his laptop, attach a bit.ly link, and ship. No CI cost, no hosting cost.
• Zack's son's micro-greens site: Built with Zephyr because he could "add one line of code, didn't have to set up GitHub pipelines, didn't have to set up anything complex, and every single time he builds, it's deployed directly to the edge."
• The key Nestor point: "You don't need a repo. We are, I believe, the only provider that does this — you are not bound to any technology outside of the actual bundler. As long as something runs on your computer and it builds, it uploads to Zephyr." — Nestor

4. End-to-end deploy: a build is a preview at the edge in ~150ms

Every build is a fresh ephemeral URL.

• The flow: Generate a project with any bundler (RSBuild in Zack's demos), run the codemod, run a build, authenticate (like Firebase or Vercel), assets upload directly to the edge.
• The default provider: Cloudflare, on Zephyr's account. You can swap in your own Cloudflare, AWS, or Fastly account.
• The number: Each build produces a new URL in roughly 150 milliseconds. Promotions to production happen in around 80 milliseconds.
• The shift: "I didn't have to make a commit. I didn't have to open a pull request. I didn't have to wait for CI to build it again. I literally do a build and I can share that with anyone in the world." — Zack

5. Bring Your Own Cloud — privacy and isolation by design

The enterprise-friendly architecture choice.

• The model: Default Cloudflare account is provided. If you're enterprise or privacy-conscious, you bring your own Cloudflare/AWS account.
• The isolation: "If for whatever reason the Zephyr dashboard or the Zephyr API is malfunctioning in some way, that is not going to block you from deploying and consuming your applications. It is going to be isolated on your Cloudflare account." — Nestor
• The privacy guarantee: Zephyr cannot snitch into or see anything inside a customer's own cloud account. "Bring your own cloud is very appealing to enterprise." — Zack

6. Zephyr is about composition, not deployment

This is the line that reframes the whole product.

• Nestor's framing: "The way I tell people to think about Zephyr — it is not about deployments, it is about composition. So how do you want your application like? I want this piece from there, that piece from there, and that piece from there." — Nestor
• The e-comm example: A large e-commerce site with separate teams owning the header, product listing, and product details. Each team can run its own version in production, iterate independently, and roll back individually if production goes sideways.
• The agentic use case: "If you have 10 multi-bots working on different parts of your site... giving them each a microfrontend to iterate on reduces their context, reduces their blast radius, allows them to iterate faster and compose without even committing to see what's the proper version." — Zack
• Nestor's "bad apple" demo: He turned the entire 3-minute-and-1-second Bad Apple video into 5,200+ standalone microfrontends, each frame a remote, all loaded sequentially through Zephyr. Probably the largest federated application in existence.

7. Reverse tree shaking — developers ship microfrontends, end users get a monolith

The performance unlock most teams don't know they need.

• The problem: Federated apps tend to ship more code to the browser than a monolith would. Bundlers tree-shake at the MFE level, but they don't know how the full app is composed.
• The Zephyr trick: Because Zephyr knows the full composition at runtime via its manifest, it can tree-shake the already-shaken bundles again at the edge — as a monolith.
• The naming: "We call it reverse because we're starting from the monolith and then moving down." — Zack
• The result: "End user experiences a monolith that developers and the teams get to function as microfrontends." — Zack

8. Hot-swap any microfrontend in any environment via the Chrome extension

The DX feature Nestor is most proud of.

• The pain it kills: In other platforms, working on a cart MFE means spinning up the shell, auth, backend, doing a docker compose up and frying your low-powered Windows laptop.
• The Zephyr workflow: Build the single MFE you're working on (10–20ms), open the Zephyr Chrome extension, point the cart MFE to your localhost in any allowed environment. That's it.
• For prod bug fixes: You can hot-swap your locally-built fix into prod on the edge for yourself, verify the fix actually works, then open the PR. No more "I think I fixed it, three environments later I realize I didn't."
• The non-engineering win: "Just go to your manager and say, hey, do you think this fits the requirements? And just give him a URL." — Nestor
• Why it's not Ngrok: "If Ngrok, if you shut down your laptop, that preview environment goes away. Whereas this is — my co-founder or someone on the team can send me a link and when I wake up I can go take a look at it." — Zack

9. State management: keep it on the host and stop talking sibling-to-sibling

The single biggest architectural mistake teams make with microfrontends.

• The rule: "Please keep the state on the host. Please keep the state on the host. Share the state accordingly. And please for the love of God, have a strategy to it. Because otherwise it is going to work — it is 100% going to work — but you are going to get regressions every single time and you are not going to know where they are coming from." — Nestor
• The anti-pattern: Sibling-to-sibling MFE communication. You don't know if a sibling is loaded, you don't know if it's the right version, things get dirty fast.
• What to use instead: Proper events into the MFE, suspense boundaries, prop drilling — keep the shell as the source of truth.
• The over-engineering trap: "A lot of people try to overcomplicate things. You don't need seven environments. You don't need seven S3 buckets. The way that people thought about doing things safely doesn't apply anymore." — Zack

10. Edge-native env vars and feature flags — override without redeploying

A beta product rolling out as we speak.

• The capability: Bundle your app with a feature flag of a given name; override its value at the Zephyr edge layer without rebuilding, re-uploading to S3, or redeploying.
• The behavior: "The next request that comes in for that microfrontend is going to have the new value. Nothing else needs to happen." — Nestor
• The architecture rationale: Zephyr controls the edge layer that serves the application, which makes it the right place to hold environment overrides and flags.

11. Federated everything — backend, mobile, desktop, MCPs

Zephyr isn't just a frontend story.

• Module federation on the backend: Nestor is actively experimenting. They're calling it "super-positioned infrastructure" — services that exist only while being observed, instead of being static assets on a container or pod.
• The Lambda HMR experiment: Module federation on Nest, deployed to AWS Lambda, doing HMR in production on a hot Lambda. "All of the architects and SREs died a little inside." — Zack
• Federated MCPs: A customer asked them to build a federated MCP. Done. "Now we can have versioned and federated MCPs that are orchestrated at the enterprise level." — Zack
• Mobile via Metro: Working with Jakub on Metro support so Zephyr can ship over-the-air updates for mobile.
• Desktop via Tauri: Already working.
• The widget loader: A travel customer needed to serve federated remotes on third-party websites. Zephyr built a loader that does it without iframes, using Shadow DOM. "For all of the Angular lovers out there, I brought back Shadow DOM." — Zack

12. The Node.js ESM unload PR — toward HMR for Node in production

A small spec change with massive implications.

• The issue: When you unload an ESM module on the V8 engine, it leaks memory. V8 was never built for that path. One leak is fine. A hundred? V8 dies.
• The work: Zephyr is working with Yagiz from the Node.js core team on a TC39 / ECMA spec proposal to fix this. The PR is open, the TC39 meeting is public.
• The use case: HMR for Node applications in production. Live module swaps, not just dev-loop reloads.
• The community signal: "He said it actually felt kind of suspicious because he's never had so much positive feedback on a pull request." — Zack

13. Pricing: free for one human, $19/seat for teams, whole-org for enterprise

The model is intentionally not seat-greedy at scale.

• Free tier: One user, generous limits. 120 GB/month of egress before bandwidth charges. "If you're doing 120 gigs a month in egress, you're doing something intense." — Zack
• Teams: $19 per person, up to 10 people.
• Enterprise: Whole-org access, no seat counting. "We care more about productivity. Having every person in the organization have access is more valuable than trying to figure out exactly how many seats to buy." — Zack
• What's not metered: Number of microfrontends. "Could be Nestor with 5,284 microfrontends." — Zack

14. Open source posture and the founder reality

Zephyr is building the platform — and paying the open source bills around it.

• What's open: Module federation itself (~6.3M weekly downloads — larger than Angular). Zephyr's bundler plugins. Likely the Chrome extension soon.
• What's not: The Zephyr platform itself.
• Open Collective sponsorships: RSBuild/RSPack folks, NAPI, SWC, Nitro, Tailwind. "We didn't want to just be another company that's just consuming. Even as a startup, we're doing it." — Zack
• The founder reality: Four kids, lives in Atlanta, still married. "It kind of breaks a lot of the perceived nature of what it means to be a startup. It doesn't mean I don't work my butt off. It doesn't mean I'm not sitting on a football field in the summer working on a laptop, or on a customer call at 11 o'clock because Nestor's already asleep in Spain." — Zack
• The kids' question at the dinner table: "Did you get any new angels today, daddy? Did you get any customers yet?" Almost lost the house during the first round. Now close to default-alive.

🧠 What I Learned

• Module federation is the Docker layer for the frontend; Zephyr is the Kubernetes-plus that orchestrates it.
• You don't need microfrontends — or even a Git repo — to use Zephyr. You just need a bundler that builds.
• Every build is an ephemeral edge URL in ~150ms; promotions to production happen in ~80ms.
• The real Zephyr value is composition, not deployment — pulling pieces of an app from different versions of different teams' MFEs at runtime.
• Reverse tree shaking lets developers ship microfrontends while end users receive a monolith-shaped bundle.
• The Chrome extension hot-swaps any MFE (including yours, locally) into any allowed environment — including production for fix verification.
• State should live on the host. Sibling-to-sibling MFE communication is the most dangerous antipattern in the space.
• Edge-controlled env vars and feature flags can be overridden without a redeploy.
• Module federation is heading to the backend, mobile (via Metro), desktop (via Tauri), and MCPs.
• Zephyr is co-driving a TC39/Node.js PR to fix ESM unload memory leaks — a precondition for production HMR in Node.
• Pricing: free for individuals (120 GB egress), $19/seat for teams up to 10, whole-org for enterprise.
• Open source posture: Module federation stays open (6.3M weekly downloads), and Zephyr financially supports the bundler ecosystem via Open Collective.

💬 Favorite Quotes

"Module federation, we affectionately call Docker for the frontend. And then Zephyr is like the Kubernetes-plus in that analogy." — Zack

"The way I tell people to think about Zephyr — it is not about deployments, it is about composition." — Nestor

"You don't need a repo. As long as you have something running on your computer that builds, it's going to upload to Zephyr." — Nestor

"Please keep the state on the host. Please keep the state on the host. Share the state accordingly. And please for the love of God, have a strategy to it." — Nestor

"End user experiences a monolith that developers and the teams get to function as microfrontends." — Zack

"We were doing HMR in production on a Lambda while it was still running, hot-swapping the code that was on it. All of the architects and SREs died a little inside." — Zack

🎯 Also in this Episode

• Nestor's Sencha.js / ext.js iframe origin story from almost a decade ago
• How TikTok runs a microfrontend architecture at one of the largest scales on the web
• The bundler relationships behind Zephyr — RSPack (open-sourced with ByteDance), Webpack via Zach Jackson, and Vite
• The "bundler company" identity Zephyr held early on
• Nestor's 5,200+ microfrontend rendering of the Bad Apple music video
• The federated MCP server — versioned, federated, enterprise-orchestrated MCPs via module federation
• Reframing reverse tree shaking as "starting from the monolith and moving down"
• The "five Devins, pick the one you like" multi-agent design workflow
• Why feature flags are usually abused as a safety net for not testing properly
• Nitro support coming soon (with Pi Zero / Puya from the Angular team)
• TanStack Start, Next, and other server-side framework integrations on Nestor's roadmap
• Mobile microfrontends via Metro with Jakub
• Desktop deploys via Tauri
• The AI platform Zephyr is launching — a multi-agent multi-human productivity tool, "a Rust replacement for Slack" by the SWC creator Kdy and the Tauri team
• Pilot results from the AI platform: 10% more accurate, 30% faster, 40% cheaper
• The Goldilocks zone of "faster, cheaper, better" — usually you only get two
• Nestor speaking at the London conference in April

Resources

More from Zack and Nestor:

• Zephyr Cloud
• Module Federation — 6.3M weekly downloads
• RSPack / RSBuild — open-sourced with ByteDance
• Hono — backend framework Zephyr migrated to
• Shadcn — UI library Zephyr migrated to from MUI
• Nitro — server runtime Nestor is integrating
• TC39 ESM unload PR / Node.js core proposal — open and discoverable in the Node.js repo

🎧 Listen Now

🎧 Spotify
📺 YouTube
🍏 Apple Podcasts

Episode Length: 57 minutes on module federation, microfrontends as Docker for the frontend, edge composition, reverse tree shaking, and what venture-backed platform engineering looks like with four kids and a 5,200-microfrontend Bad Apple demo.

If you've ever fought a CI/CD pipeline to ship a splash page, debugged a sibling-to-sibling MFE state bug at 2am, or wondered why your federated app is shipping 40% more JS than it needs to, this conversation is for you.

Happy building,
Dan