Self-hosting micro frontends: a compliance-first guide
In a regulated environment the first question is not how it scales, but where the data lives and who can prove it. What self-hosting has to answer.

In a bank, an insurer or anywhere else with a regulator, the first question about a new tool is never how well it scales. It is where the data lives, what leaves the network, and who can prove both a year from now. Tooling that cannot answer those does not get a technical evaluation — it gets declined.
Micro frontend infrastructure sits in an awkward place for this. It is developer tooling, so it tends to be evaluated as developer tooling, but it touches build artefacts, environment configuration and the release path into production. That makes it in-scope for questions most frontend tools never face.
What actually leaves your network?
Start here, because it is the question with the most wrong answers. Three flows are worth separating: the build artefacts, the configuration describing what each environment serves, and any telemetry the tool reports about itself.
Artefacts and configuration are the ones that matter. If they sit in a vendor's account, the vendor is in scope for your data residency story. If they sit in your own object storage, they are covered by controls you already have — which is usually the difference between a short conversation and a long one.
Where should the artefacts live?
In storage you already own and already audit. A micro frontend build is a static bundle, so the requirement is ordinary: a bucket in your cloud account, with your encryption, your retention, your access policy, your logging.
The useful property of this arrangement is that it needs no new controls. An S3 bucket with the policies your organisation already applies to buckets is not a new risk surface, and it does not need a new review.
What does encryption at rest actually cover?
Ask precisely, because the phrase is used loosely. Storage-level encryption protects the disk, and is table stakes — usually the cloud provider's, usually already on. It does nothing about who can read a value through the application.
The question worth asking is what the tool encrypts at the application layer, with a key you hold: credentials for connected systems, tokens for repositories, environment secrets. And the follow-up nobody asks until it matters — what happens if that key is lost. A tool that cannot tell you which fields are covered and what losing the key costs has not thought about it.
What does an audit actually need?
- Who changed what, when. Which version each environment serves, who changed it, and at what time — retained long enough to matter.
- Immutable artefacts. A version that can be overwritten in place is a version you cannot attest to. Deployed builds should be write-once.
- Separation of duties. Whoever can publish a build should not automatically be whoever can promote it to production.
- A reproducible path from commit to production. Which commit produced the artefact currently serving customers, established from records rather than memory.
Notice that none of these are frontend concerns. They are the same controls your backend deployments already answer, applied to a part of the stack that historically escaped them because it was just static files.
Does self-hosting mean giving up the convenience?
Partly, and it is worth being straight about it. Self-hosting means you run the thing: a container, a database, a cache, backups, upgrades. That is real operational work, and for an unregulated team it is usually not worth it.
What you get is that the data residency question stops being a question. For an organisation where a vendor holding build artefacts requires a review that takes longer than the integration itself, running it yourself is the faster path, not the slower one.
What to ask a vendor before anything else
- Can this run entirely inside our network, with no outbound dependency at runtime?
- Can artefacts live in our own storage account rather than yours?
- Which fields are encrypted with a key we hold, and what happens if we lose it?
- What is recorded when someone changes what an environment serves, and for how long?
- What does the tool report about itself, to whom, and how is that turned off?
If the answers are clear and documented, the technical evaluation can start. If they arrive as reassurance rather than specifics, you have learned something useful anyway.


