← All posts

Doing it by hand versus a control plane

You can manage micro frontend versions with a JSON file and a script. Here is exactly what that costs, and the point where it stops being the cheap option.

Lorenzo De Francesco· Maintainer4 min read
A split image: on the left a hand-annotated JSON file tangled with wires, sticky notes and a warning sign; on the right a tidy dashboard with an ordered version list and a checkmark.

Every team that adopts micro frontends builds a small version of this. A JSON file somewhere, a script that writes it, a convention everyone half-remembers. It works, and for a while it is unambiguously the right call.

This is an attempt at an honest account of what it costs — written by people who sell the alternative, which you should weigh accordingly.

What does doing it by hand look like?

At its simplest: a JSON document in object storage mapping each micro frontend to a URL, fetched by the host on startup. A CI step uploads a build and rewrites the document. Releasing is a write; rolling back is writing the previous value.

That is perhaps fifty lines of code, and it already delivers the important part — the version is runtime data rather than a build-time constant. If you take one thing from this, take that. It matters far more than what writes the file.

What works fine by hand?

  • Few micro frontends, one or two environments. The mental model fits in a head. Everyone knows what is deployed because everyone was there.
  • One team. No permission problem, because there is nobody to grant permissions to.
  • Low release frequency. A weekly release does not need tooling to keep track of.
  • High trust, low stakes. If a wrong version means an awkward afternoon rather than an incident, the controls can stay informal.

Where does it start to hurt?

Not in one dramatic moment. It erodes, and the failures are recognisable:

  • Nobody can say what is live. Answering requires opening a bucket, reading JSON and trusting it is current. The answer exists; it is just not available to anyone who needs it.
  • “The previous version” becomes a memory. Rollback assumes you know what to roll back to. Without a history, that is recollection under pressure.
  • Whoever can write the file can change production. Storage permissions are rarely the permissions you would have chosen for a release mechanism.
  • A typo serves a blank page. An unvalidated version string fails at the worst layer — in the browser, for customers, with no error anywhere in CI.
  • Nobody can reconstruct what happened. After an incident, the question is who changed what and when. A file that was overwritten in place cannot answer.

What would you actually have to build?

If you set out to fix those properly, the list is not the file. It is a history of versions per environment, a view showing what is live without opening storage, permissions separate from bucket access, validation before a write, an audit trail, and a path for CI to publish and register a build in one step.

None of it is hard. All of it is the boring part, and it competes for time with the product you are actually paid to build. That is the real cost — not difficulty, but where the hours come from.

When is a control plane not worth it?

When the list above describes problems you do not have. One team, two micro frontends, a weekly release and a shared understanding of what is deployed — the JSON file is genuinely the right answer, and adopting anything larger is buying controls for risks you are not carrying.

The threshold is not a number of micro frontends. It is the first time someone asks what is live in production and the honest answer is “let me check” — and the check involves a bucket.

What we built, and why

Opsburg is the list above, implemented once so each team does not implement it again: a version history per environment, deployments as immutable snapshots, runtime configuration served to the host, permissions, an audit trail, and CI integrations. It is open source and self-hostable, because for a lot of teams the thing that decides adoption is where the artefacts live.

But the honest version of this piece is the same as the honest version of the last one: start with the JSON file. Move the version out of the build, live with it, and let the file tell you when it has stopped being enough. It will.

Keep reading

Self-hosting micro frontends: a compliance-first guide

4 min readmicrofrontends

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.

Do you actually need micro frontends?

4 min readmicrofrontends

Micro frontends solve an organisational problem before a technical one. If you do not have that problem, they mostly add work. An honest checklist.

Module Federation with Vite in production: what changes

4 min readmicrofrontends

Module Federation works with Vite, but dev and build take different paths, and the gap is where production surprises come from. What to expect.