Why we built our own framework instead of renting one

Every agency has had this week: a client's site goes down, and the cause is four layers deep in software nobody in the building wrote. A plugin updated itself. The update needed a newer CMS version. The newer CMS version broke the theme. The theme vendor's fix is 'coming soon.' You can't fix any of it — you can only wait, apologize, and invoice for the waiting.

We got tired of apologizing for software we didn't write. So we stopped using software we didn't write.

The rented stack, itemized

A typical agency build sits on a stack that looks something like this:

• A CMS someone else maintains, on their schedule
• A theme layer that fights the CMS on every major update
• A plugin ecosystem where every added feature is a new stranger with keys to the site
• A hosting platform with its own opinions, limits, and pricing cliffs

Each layer is individually reasonable. Together, they mean that when something breaks, the answer to 'who can fix this?' is usually 'not us.' That's not a technology problem — it's an accountability problem. You can't stand behind what you can't reach.

What owning the stack actually means

Vanolee Arc is our own framework, written in Rust: the HTTP server, the routing, the rendering, the content pipeline, the form handling, and the visual page builder are one codebase with one bar for quality. When a client asks why something works the way it does, the answer is never 'that's just how the platform is.' We wrote the platform. If the answer is wrong, we change it.

That has practical consequences that show up in the work:

• Pages render on the server as plain HTML, in single-digit milliseconds — because nothing sits between the request and our code
• There is no plugin layer, so there is no plugin update cycle, and no plugin security surface
• Secrets live on the server, full stop — the framework has no mechanism for leaking them into browser JavaScript, because we didn't build one
• When the framework needs a capability, we add it to the framework — every client site inherits the improvement

The honest cost

Building your own framework is not free, and pretending otherwise would undercut the whole argument. It means we move slower than an agency that npm-installs its way to a demo. It means no Stack Overflow answers for our own bugs. It means the burden of proof is on us, permanently: every convenience a rented platform hands out for free, we have to justify rebuilding or justify living without.

We think the trade is worth it for one reason: the failure modes are ours. When something breaks, it breaks in code we can read, fix, and test the same day. Our clients aren't waiting on a vendor's roadmap, because we are the vendor.

A stack you rent is a stack you apologize for. A stack you own is a stack you answer for. We'd rather answer.

The site you're reading is the proof of concept — same framework, same pipeline, same bar we ship to clients. View source. It's just HTML, fast.