Skip to content
Rafhael Marsigli
7 min read

From Laravel to Go: rebuilding Rush CMS from scratch

From Laravel to Go: rebuilding Rush CMS from scratch

Rush CMS was born in 2025, built on Laravel 12 and Filament 4, and I spent a long time testing and tuning it with thirteen different companies, on thirteen sites built with Astro. It even powered this blog (which now runs on the new version). It works, and it works really well, but I still decided to rewrite it from scratch, in Go, with a React admin.

Crazy? Maybe (and most likely yes), but let me explain why.

What is Rush CMS? Can you eat it?

First things first: you can't eat it!

Rush is a headless CMS built for agencies: one install, many clients, each with their own isolated site, their own users and their own permissions. Content is edited in an admin panel and delivered through a public API designed for SSG and SSR sites, with caching and automatic deploys whenever something is published.

There are already huge solutions out there with (much, much, much) more money behind them. But I had my own pain points that, back then, none of them solved for me:

  • First-class multilingual content
  • Multi-tenant by default
  • A publishing workflow with drafts, revisions, scheduling and preview
  • Self-hosted and open source

All of it together, with no plugins required.

Laravel + Filament is excellent

Before anything else I want to make this very clear, so I don't offend my PHP friends: I still use Laravel in plenty of projects, and Filament in some of them. You can launch and validate products at the speed of light. It's genuinely great, and in no time I was working with real clients on a real system with collections, forms, menus, categories, media, custom blocks, databases... and lots of other "little things".

The problem was the fit, and the direction I was taking Rush in.

It stopped being a headless panel where I edit the content of all my sites and, over time, turned into a real headless system for agencies. The first version already offered isolated multi-tenancy in a single install with per-site permissions; first-class multilingual content; and a public API designed for static sites.

In v1, each of those points meant fighting the conventions, and constantly changing and bending things to fit what I wanted. I had the speed, but I was losing flexibility.

In the current version, built in Go, I implemented a publishing model with separate drafts, revision history, scheduling and draft previews, much like Sanity, Contentful, Strapi and Payload do. And all of it works together with first-class multilingual content.

Why Go?

Having apologized to Laravel, I have to be honest. I was already learning Go and getting ready to take that knowledge into new market opportunities, and there's no better place to do that than your own projects, taking on the risk of your own decisions.

This was the ideal challenge: a multi-tenant headless CMS with queues, image processing and concurrency rules is a good place to start. I wrote down a few thoughts while frying my brain building Rush all over again:

  • Explicit, almost to a fault: errors are values, dependencies are passed by hand, and there's no magic. I was already prepared, and eager, to work without magic, so that paradigm had already been broken in my head.
  • Verbose: this is not a compliment, what ugly code!
  • A single binary: server, queues and image processing in the same process. This is what hooked me from the start, it was exactly what I wanted: one lean compiled binary. Outside of it, just Postgres and Redis.

In the new version, i18n moved from translatable JSON fields to separate tables. I'm not using an ORM: there are more than 300 typed SQL queries generated with sqlc. What's published lives in its own tables, derived from immutable revisions, and webhooks, cache and deploys come out of an outbox with retries.

And what did I lose? Well... everything Laravel handed me, I had to write myself. Laravel is unbeatable at that.

How much of the code I wrote

In today's AI culture war, one side will call me a purist and the other a heretic, or the other way around. A good part of the code was not written by me.

But if you're learning the language, you have to write it yourself.

Yes and no. I get the need for practice, but a lot more happens in our heads than on paper. We're in the middle of a complete shift in how we work, and the market often wants the fastest delivery. I still think you need to know what is being written and done, and more than ever understand system design, business rules and so on. If I had chosen to write everything by hand, I'd finish in two years, and that's being optimistic.

That was another reason, maybe the most interesting one, for rebuilding from scratch in a new language. Here's what worked:

  • Every decision is mine: each work package must have every loose end tied up, every major decision has to be recorded and easy to find, and a plan only runs after a human has validated it.
  • Explicit rules: no duplicated code, no comments, strict typing, deterministic tests... The coding guidelines have to be followed religiously.
  • Independent review: before anything reaches me, a fresh agent reviews it with no contact with the agent that wrote the code. It works well: this snitch almost always finds a problem or a broken guideline before it gets to me. I save time and the delivery gets better.
  • Mutation tests: if there's one thing agents love, it's writing tests that always pass. Having the whole project tested is great, and today you can be the testing maniac without actually being a maniac. On top of the usual kinds of tests, mutation tests are essential to catch a lazy test with its pants down.
  • Stop and ask when needed: when a spec doesn't cover a case, the agent decides on its own. That's where things can get expensive. When I notice something I don't like, I stop it right away and dig into it. Sometimes it's a good call, better than mine; other times, not so much!

Things have moved fast. I used to have my late AIPIM, which managed contexts and tasks with agents on its own. Then Claude Code subagents came along and got so good they retired my dear old package. Today I run a main agent that dispatches subagents (which, depending on the size or complexity of the spec, can dispatch subagents of their own, a real agent inception), executing the spec through task graphs that have already been reviewed and approved.

Today the new version has about 35k lines of Go, 49k lines of tests and more than 800 commits since March 2026.

So what does this whole wall of text mean?

That sometimes the crazy decision to rebuild from scratch can be a good one. At least here it was! I could have stuck with plain PHP, Symfony, or even Laravel with Inertia, but what would I have learned?

Symfony would have handled it with one hand tied behind its back, but I'd only be fixing the Filament fit, still in the same language I've used for the last 15 years. And Inertia didn't make sense: Rush is headless, the API is the product, so the admin became just another client of it.

Leaving my comfort zone was my final choice.

What comes next?

Being self-hosted and open source were two of the requirements that, together, made me build Rush CMS. For now, it still isn't.

Rush CMS (the new version, in Go) will become an open source repo once I've validated it and solved my main current pain points, starting with an open beta on the official GitHub repository. Once it's released, that will be the link.

Start typing to find something.