Choosing a Go full-stack approach in 2026
"Which Go framework" is the wrong first question, because the options are not competitors. PocketBase, Encore, Goravel and a code generator are four different kinds of thing, and most comparison tables line them up as though choosing between them were a matter of features.
The useful question is which bargain you are making, and what it costs to leave when the product outgrows it. That cost is the thing nobody puts in the table, and it is the thing you will care about in year two.
19 min read. Commands and output last run against Grit v3.560.0.
What you will have at the end
Four categories, and which questions put you in each.
The exit cost of each, stated plainly.
A section on when not to pick Grit, which is a real list.
For a per-tool comparison
This page is about the decision. For eight specific tools, Buffalo, Beego, Bud, templ, Encore, PocketBase and the rest, with what each one actually includes, the options are compared individually here.
Four kinds of answer
1. A runtime backend
PocketBase, Supabase, Appwrite. You get a running server with a database, auth, file storage, realtime and an admin interface, and you write against its API. The product is the server.
The bargain: almost nothing to build, and your application lives inside somebody else's process model. Custom logic goes in hooks or an extension mechanism rather than in your own request handlers. PocketBase is a single binary with embedded SQLite, which is genuinely excellent for a tool, an internal application or a product that stays small.
The exit cost: high, and back-loaded. The data is portable; the application is not, because your logic is written in terms of the platform's extension points. Leaving means rewriting the backend.
2. Infrastructure from code
Encore. You declare a database, a queue, a cron job in Go, and the framework provisions and wires them, locally and in the cloud, with tracing and dashboards.
The bargain: an enormous amount of infrastructure work disappears, and your code is written against the framework's declarations. It is a strong idea executed well, and it is most valuable when you have several services and nobody who enjoys Terraform.
The exit cost: moderate to high. The business logic is ordinary Go; the wiring is not, and reproducing what the framework was doing for you is the work.
3. A code generator
Grit, and in other ecosystems Rails scaffolding or Laravel with Filament. The tool writes ordinary code into your repository: models, handlers, routes, frontend, admin screens. Then it gets out of the way.
The bargain: you own everything it wrote, so there is no ceiling on what you can change, and there is also no magic doing anything for you at runtime. What you give up is that generated code is code you did not write and must still review, understand and maintain.
The exit cost: low by construction. Stop running the generator and you have a Gin and GORM application, which is what you would have written. "Ejecting" is not a feature because there is nothing to eject from.
4. Libraries, assembled
Gin or Echo, GORM or sqlc, your own structure. The default, and for many services the right one.
The bargain: complete control, and you build auth, the admin, migrations, file uploads, background jobs and the frontend plumbing. Every one of those is a known quantity and a week or two, and they add up to a quarter you did not spend on the product.
The exit cost: none, and that is the point. The risk is not lock-in, it is the five identical plumbing problems each solved slightly differently by whoever got there first.
The questions that actually decide it
- Will you need custom business logic in the request path? If yes, a runtime backend will be fighting you by month three. If no, it may be the fastest route to a working product by a wide margin.
- Does an operator need to administer the data? Almost every product eventually says yes, and the admin panel is where unbudgeted weeks go. A database browser is not an admin panel: it has no business rules, no validation and no audit trail.
- Who maintains this in three years? Generated plain Go can be maintained by any Go developer. A framework-specific runtime requires somebody to learn the framework, and a popular framework is a much safer bet than an elegant one with four contributors.
- How much infrastructure are you willing to operate? One SQLite file, one Postgres and one Redis, or a cluster. This narrows the options faster than any feature does.
- Is the frontend part of the same decision? If you have a React team and a React application already, anything that wants you to write Go templates is not in the running whatever else it offers.
When not to pick Grit
A list like this is worthless if it concludes that the tool you are reading about is always right. These are the cases where it is not.
- You are building a library or a single-purpose service. A metrics collector, a webhook relay, a CLI. There is no frontend, no admin and no CRUD. Use the standard library and one router.
- Your frontend is not React. The generated frontend is Next.js or a Vite React application. With Vue, Svelte or server-rendered Go templates, you are using the backend half and writing the rest, which is a smaller benefit than the page suggests.
- You want no generated code in your repository. Some teams hold that position and it is coherent. A generator is the wrong shape of tool for it.
- You already have a large, working Go codebase. Adopting a generator mid-life means reconciling its conventions with yours. Take the individual pieces if they help, and do not restructure a working system around a tool.
- Your data model is not relational. Event-sourced, document-shaped or graph-shaped domains do not fit a resource generator built on GORM, and forcing them to is worse than not using it.
- You need a very small deployment footprint. A single binary with embedded SQLite and an admin interface is PocketBase, and nothing here beats it on that specific axis.
And the honest risk
Grit is young and maintained by a small team. That is a real consideration, and the mitigation is structural rather than promissory: it generates ordinary Gin and GORM code into your repository, so a project survives the tool. If the generator stopped being maintained tomorrow, you would have a Go application that builds, runs and can be changed by anybody who knows Go. That is the main argument for the generator shape over the runtime shape, and it applies to the risk as much as to the ceiling.
Measuring lock-in properly
"Lock-in" is used loosely. A useful definition: how much of what you have written would have to be rewritten if the tool disappeared.
Libraries assembled nothing. You wrote it.Code generator nothing. It wrote ordinary code, in your repo.Infrastructure-as-code the wiring, the deployment, the observability.Runtime backend the backend. The data exports; the logic does not.
That ordering is not a ranking. A high exit cost can be entirely worth paying: if a runtime backend takes your product to market three months earlier, and most products never need to leave, the bargain was good. The mistake is making it without noticing.
The honest test for any tool: what does the code look like if I stop using it? Ask it before adopting, not during the migration.
Why performance is not in this page
All of these are Go, and Go is fast enough that the framework is not what makes your application slow. Your database is, and specifically the queries you wrote against it.
Router benchmarks measure a hello-world handler over a loopback interface. The difference between the fastest and the slowest is tens of microseconds, against a database query of tens of milliseconds, which makes it about a thousandth of the response. Choosing on that number is choosing on noise.
What does differ, and is worth asking about: how many queries the default list endpoint makes, whether pagination is on by default, whether a relation is preloaded or produces an N+1, and whether there is a profiler to answer those questions when something is slow.
Spend an afternoon rather than a week reading
Each of these can be stood up in under an hour. Build the same small thing in two of them: one resource with a relationship, a list with a filter, an admin screen, and a deploy. You will learn more from that than from any comparison, including this one.
# Grit$grit new demo && cd demo && grit start# PocketBase$./pocketbase serve# Encore$encore app create demo && encore run
Three things to notice while doing it, because they are what you will live with:
- What happens when you need something the tool did not anticipate. Is there a door, and where does it lead?
- What the error messages are like when you get it wrong. You will spend more time with those than with the documentation.
- Whether you can read the code that runs your application. Not whether it is pretty: whether it exists somewhere you can open it.
Frequently asked questions
- Is there a Rails or Laravel for Go?
- Not in the sense of one framework the community agrees on. Go's culture pushes against large frameworks: the standard library is capable, the ecosystem favours small composable packages, and the result is several partial answers rather than one dominant one. Goravel is the closest attempt at a deliberate Laravel port; Buffalo was the closest in spirit and has slowed.
- Is PocketBase good enough for production?
- Yes, for the shape it fits: one binary, SQLite, an admin interface included, vertical scaling. It runs real products. The limits are the ones that follow from that shape, a single writer and a single machine, and the fact that your custom logic lives in its extension model rather than in your own handlers. Both are acceptable until they are not, and the point at which they stop being acceptable is predictable.
- Why is generated code better than a framework doing it at runtime?
- It is not better in every way; it is a different trade. Generated code is readable, debuggable with ordinary tools and changeable without permission, and it is also code you did not write that you now maintain, and it does not improve when the tool does unless you regenerate. Runtime magic is less to maintain and harder to see into. Pick based on which failure you would rather have at three in the morning.
- What if I pick wrong?
- For most of these the answer is a migration rather than a catastrophe, and the cost is the exit cost above. The decision that is genuinely hard to reverse is not the framework, it is the data model, and in a multi-tenant product specifically it is whether a tenant is a user or an organisation. Spend your anxiety there.
Next steps
- The eight options, individuallyBuffalo, Beego, Bud, templ, Encore, PocketBase and the rest, in detail.
- Go or Node.js for your backendThe decision before this one, if it is not settled.
- Go project structureWhat you are choosing between if you assemble it yourself.
- What Grit is and is notThe reasoning behind the generator shape, from the inside.
