MolnOS: The Microscale Cloud You Own

It’s the microscaler cloud you own, fits on a floppy disk and runs on a €10 Raspberry Pi Zero (if you want it to).

There’s a strange thing about clouds…

Something that—going on the word—should be very light, almost ethereal, also happens to be extremely tangible and cumbersome. Not just in terms of tons of metal, amount of plumbing, need for air conditioning and miles of fiber optic cables, but the burden they often impose on you as an engineer.

The bigger a cloud gets, the more abstract they become. More regions, more services, more SKUs, more dashboards, more YAML—and if you are in enterprise—more consultants. If you are lucky, concepts stay aligned over the years and don’t get mixed up with new similarish ideas.

Somewhere along the way, the idea that you could actually understand the thing you’re running on quietly disappeared.

And maybe, cynical as I am, that was always the idea of the commercial cloud: AWS (et al) making you think you’re too stupid to do ops on your own. “We’ll cover your ass, you do your app thing, kid”.

Don’t get me wrong. Based on my Medium and GitHub histories, and my employment record, you’ll see that I kind of like the Cloud™. I am happy to call myself “cloud native”. The constructs we’ve invented (at least some of them) are great. It’s just that it’s gotten a bit ridiculous and unproductive as marketers are getting itchy and the cloud monoliths are not getting any more focused and we suffer riotous bouts of violent neckbeard infighting over… something.

That’s the reason I committed the cardinal sin of building my own cloud: MolnOS.

Dashboard view of a pretty fresh MolnOS instance.

A cloud that fits in your head

MolnOS is a microscale cloud. It’s tiny by design. It fits on a floppy disk. It runs on a €10 Raspberry Pi Zero if you want it to. And yet, it gives you most of the things people actually use cloud platforms for.

On naming: “Moln” is Swedish for cloud. “OS” because it acts as the control plane of a cloud. If hyperscalers have an internal “cloud OS” (they do, even if they don’t really call it that), then MolnOS is the honest, portable version of that idea.

Not a demo cloud. Not a toy. A real cloud.

The idea came from a set of quite simple questions:

  • What if a cloud wasn’t something you rented forever, but something you owned?
  • What if it was small enough to understand, distribute, and operate yourself — without a dedicated platform team or a decade of tribal knowledge?
  • What if that cloud actually performed better under normal use than commercial offerings?
  • Qualifier: What if that option was not OpenStack or some other megalithic hunk o’ junk?

This is the gap MolnOS lives in.

Batteries-included

MolnOS includes the core primitives that make a cloud useful — without the ceremony.

You get all the important cloud pieces:

  • IAM: powerful but simple
  • Applications: auth, even for external apps
  • Functions: zero cold starts; has bindings and permissions
  • Sites: static site hosting just like your favorite option out there
  • Databases: key-value database based on PikoDB
  • Storage: “S3-like” object storage
  • Observability: logs focus

All of this runs under one control plane with a single mental model; one system you can actually explain to another human being.

And yes — permissions, bindings, and security are first-class concerns. Small doesn’t mean sloppy!

The only thing you’ve got to bring to the party is an SMTP provider that takes app passwords (like Proton or Google or many others) to send auth emails.

Staying true to the design goals

One of my design goals with MolnOS was to keep it aggressively light, yet powerful and familiar.

  • The Core is ~400KB and does all the heavy lifting.
  • The CLI (you get it when installing it with the curl oneliner below) has completions and most/all (?) of the niceties you’d want.
  • The Console is a ~400KB, fully optional, web console for the click-ops crowd out there.

MolnOS is opinionated, explicit, and a little stubborn. It wants you to understand what you’re deploying. It wants you to own your data. It wants you to know where things run and why.

This probably makes it a bad fit for some people — and that’s perfectly fine.

But if you’ve ever thought “why is this so hard?” while wiring together half a dozen managed services just to host a small system, MolnOS might feel like a breath of fresh air.

Not a hyperscaler, and not trying to be

I currently work at evroc, a European hyperscaler. Hyperscalers are incredible at what they do. They optimize for planetary scale, global redundancy, and massive organizations with complex needs. Their work is f***ing hard. I know since I’m in the same industry!

MolnOS is not competing with that world at all. It’s orthogonal to it.

Hyperscalers optimize for scale you might never reach. MolnOS optimizes for scale you can hold in your hands. The two approaches create very different possibilities.

A microscaler can run in places hyperscalers can’t. It can be audited completely. It can be shipped, mirrored, forked, embedded, and reasoned about in ways that simply don’t work at massive scale.

That’s not better or worse — it’s just different. And different is useful.

Why does microscale matter, then?

Because those same strengths that hyperscalers possess make them a less ideal fit for a lot of real-world use cases.

If you’re building:

  • internal tools
  • edge deployments
  • developer platforms
  • regulated or offline-first systems
  • small-to-mid SaaS products
  • private or sovereign infrastructure

…you often don’t need infinite scale. You need predictability, control, and clarity. And you really don’t want to deal with the US CLOUD Act and other nonsense for these cases.

Microscale is not about being smaller for the sake of it. It’s about being right-sized. Small enough to reason about. Small enough to trust. Small enough that when something breaks, you know where to look.

And simple:

Scaling is a simple question of vertically scaling with faster CPUs, more RAM, giving it NVMe drives.

Backups and disaster recovery is a simple question of setting up a systemd script to archive your data folder and ship it elsewhere, every once in a while.

“Simple” is a super important thing here.

Ownership as a feature

For ownership, I’m leaning equally on a very simple and useful model: MolnOS is free for any personal and non-commercial use. For commercial use, you buy it once. Version 1.x is yours, perpetually, for your organization. No salespeople or “quick video chats” involved. You pay for the software, and then you decide how and where to run it.

That’s an increasingly unusual model in software land, not to speak of cloud land. You won’t find many others offering that.

Who MolnOS is for

MolnOS is for people who like understanding their systems. For teams who want leverage without dependency. For engineers who enjoy clarity more than buzzwords.

It’s for those moments when you realize you don’t actually need a planet-scale platform — just a good one.

And if you’re curious, the docs are at docs.molnos.cloud, with a short introduction here.

Get going in seconds by running:

curl -sSL https://releases.molnos.cloud/install.sh | bash

Or if you are in the npm ecosystem (and are OK with not having the CLI), you could just run:

npm install molnos

Closing thoughts

Building MolnOS has been a long-running quest for me, with the kernel of that idea starting way back in 2018 or so, being frustrated with AWS—like pretty much everyone those/these days. Some things don’t change.

Thanks also to all the people I’ve had conversations with over the last year about this, as I’ve had more focused time to build it. No thanks to the weird looks you all gave me, when I was telling you about this crazy idea, though! 😉

If the core concepts of MolnOS resonate with you, I’d love to hear your thoughts.