Grit and Encore
These two solve different halves of the same week, which is why the comparison is usually framed wrongly. They are not competing for the same decision so much as for the same hour.
Encore removes the infrastructure work: you declare a database, a queue, a cron job in code, and it provisions, wires and traces them. Grit removes the application work: the CRUD, the auth, the admin panel, the frontend and the types between them.
What each one hands you
With Encore you write service code, and the things it depends on are declarations inside that code rather than Terraform beside it. You get a local environment that matches, request tracing without instrumenting anything, and deployment to your own cloud account or theirs.
With Grit you get a repository: a Gin and GORM API, a React frontend, an admin panel over your data, shared types generated from the Go, Docker Compose, and a deploy command. The infrastructure is ordinary and yours to run.
Where they genuinely overlap
Both want to be the thing you start a backend with, and both have opinions about project structure. If you adopt either, you are adopting its shape.
The real overlap is smaller than it looks, though. Ask what your next two weeks are actually spent on. If the answer is "standing up a Postgres, a queue and a staging environment, and working out why the traces are empty", Encore is aimed exactly at that. If it is "another twelve CRUD screens, an admin panel and keeping the TypeScript types in step with the Go", Grit is.
One service or several
Encore is designed around services, and it is at its best when there are several of them: the declarations are how services find each other, and the tracing is how you understand a request that crossed three of them.
Grit generates one API. That is a deliberate scope: most products are one service for far longer than their architecture diagrams suggest, and the admin panel, the shared types and the generated frontend all assume a single backend. If you are splitting into services on day one, Grit is not aimed at you.
What it costs to leave
Both are more portable than a runtime backend, and they are portable in different amounts.
Encore's business logic is ordinary Go. What is not ordinary is the wiring: the declarations, the generated clients, the provisioning and the observability. Leaving means reproducing those, which is real work and is work you know how to do.
Grit has nothing to leave, by construction. It writes Gin, GORM and React into your repository and does not run in production. Stop using the CLI and the project keeps building, because the CLI was never part of it. That is the single clearest difference between the two, and it is a consequence of generation rather than a feature anybody added.
Which to choose
Choose Encore when
- You are building several services and want them to find each other without a service mesh.
- Nobody on the team wants to own Terraform, and the infrastructure work is what is actually slowing you down.
- Distributed tracing across services is something you need on day one rather than eventually.
- There is no frontend in scope, or the frontend is somebody else’s project.
- Matching local, staging and production environments is a recurring source of pain.
Choose Grit when
- There is a frontend, and an admin panel, and somebody has to build both.
- The repetitive work is resources and screens rather than infrastructure.
- You want one API, and expect to want one API for a long time.
- Shared types between Go and TypeScript matter, generated rather than maintained by hand.
- You would rather deploy to a single machine with Docker Compose than adopt a platform.
They are not mutually exclusive in principle, and in practice adopting both means living inside two sets of conventions about project structure. Pick the one aimed at the work that is actually costing you.
What neither gives you
- A data model. Both let you build the wrong schema efficiently.
- An answer to authorisation beyond the basics. Scoping rows to a tenant is your work either way.
- Freedom from a database that will eventually need indexes and a migration strategy.
- A reason to split into services. If you do not have one, one service is the right answer.
Trying them
Both scaffold in minutes. Build the same thing twice and notice which parts you had to write yourself: with Encore it will be the screens and the CRUD, and with Grit it will be the infrastructure beyond a compose file. That is the trade, stated as plainly as it can be.
The longer version, across four kinds of tool rather than two, is in choosing a Go full-stack approach, and the survey page covers eight of them individually.
This page is written by the people who make Grit, so read it the way you would read any comparison written by one side. It sticks to how the two are built rather than to numbers, because numbers go stale and nobody comes back to fix a competitor's. Both projects are open and take an afternoon to try, which is worth more than this page.
