The layer above your product: what module federation means for designers
Module federation sounds like an engineering topic. It's really about who owns the experience around your products: navigation, search, AI assistant, settings. Here's how it works, and why designers should care.
Open three products from the same company and you'll often find three navigation bars that almost match. Same logo, similar icons, a menu that sits a few pixels off. Nobody planned it that way. Each team ships on its own schedule, the shared navigation is a copy, and copies drift.
I've been working with a technique that tackles this at the root. It changes how I think about what a design system can own, and about what a designer can design. It's called module federation. The name is dull. The idea isn't.
An attachment versus a link
Think about sharing a document. You can email a file, or you can share a link to a live version. The attachment is a snapshot. The moment you send it, it starts going out of date, and everyone holds their own copy. The link always shows the current version, and the owner updates it once.
Most design systems and shared components reach products as attachments. A platform team packages them up, and each product team has to pick up the new version, test it and redeploy before anything changes for a customer. Some teams do it quickly. Some don't. In my experience that gap is where the drift lives.
Module federation is the link. In plain terms, it lets one app load pieces of another app while it's running, from wherever the owner publishes them, without being rebuilt. The app doing the loading is the host. The one publishing the pieces is the remote. When the owner updates a piece, every host gets the new version the next time it loads.
The airport model

The picture that helps me most is an airport. Each airline runs its own check-in desks, planes and crews. The airport owns the signage, the gates, the wayfinding and the departure screens. When the airport changes a sign, every passenger sees it, whichever airline they're flying. Nobody asks the airlines to redeploy anything.
Now swap in software. The platform is the airport. The products are the airlines. The airport terminal is what engineers call the chrome: the navigation rail, the menu, the toolbar, global search, the company switcher. Module federation is what lets the platform team update the airport terminal once and have every product walk into the new version.
For a multi-product company, that makes a different kind of experience possible. One AI assistant that behaves the same in every product. One search. One comments system. One way of switching company that doesn't reset when you change product. A customer moves between products and doesn't feel the joins, because the layer around the products is literally the same thing.
I built a small version to see
To test this, I built a spike: two small apps on different addresses, both loading one shared shell at run time. Everything in it ran on mock data, and it was deliberately rough. It worked, which was the least interesting result. What interested me was how many of the problems it surfaced were design problems.
Where the seam goes. Someone has to decide what the platform owns and what each product controls. I decided the platform owns the whole toolbar, including the assistant, docs, page information and comments, and products don't get to fill it in. That one call shaped the engineering. I'd already tried a version where products could pass things into the toolbar, and I reverted it because it contradicted the decision. Decisions about ownership are experience decisions, and they were mine to make as a designer.
What loading looks like. My first loading state showed the page inside a thin header while the shell arrived, so the content appeared first and the navigation appeared around it. It felt wrong in a way that's hard to describe and easy to see. The fix was a skeleton at the exact size of the real shell, with the page only appearing inside the real thing.
What failure looks like. If the shared shell can't load, the product needs a fallback. A thin header would look broken to a customer, so I designed one that mirrors the real layout: the rail with product links, the app's own menu with working links, greyed-out toolbar actions, and a quiet notice explaining what's going on. Failure is a state. It deserves a design.
What the platform remembers. I saved a favourite in one app and it wasn't there in the other. Browsers store that kind of data per address, so two products on two addresses can't see each other's. A customer would never think of it that way. They'd think the platform forgot them. Deciding what a platform remembers about a person, and where, is a design question long before it's a technical one.
What it doesn't solve
I don't want to oversell this. Module federation is not magic, and the spike left real questions open. The shared shell runs inside every product with the same privileges, so the pipeline that builds and delivers it becomes something worth protecting seriously. Identity, meaning how a person stays signed in as they move between products, needs deciding. So does who owns the contract between platform and product, and how long old versions are supported. I'd treat all of these as unsolved until a team has dealt with them for real.
It also needs products built in compatible ways, and not every product will be. I'm still learning where those edges are.

Thinking bigger
The part that stays with me is the shift in the unit of design. We're trained to design screens, then flows, then systems of components. This points at a fourth thing: layers that sit outside any single product and shape every product at once. The navigation, the assistant, the search, the memory.
Someone has to design those, and design the seams where they meet each product. I'd rather that someone was a designer, in the room from the start, than someone handed a finished architecture and asked to make it look consistent.
The screens are still ours. What's changing is how much of the experience lives outside any single one of them.