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.

Encore
Grit
Removes
Provisioning, wiring, local environments, tracing setup.
CRUD, auth, the admin panel, the frontend, the types between them.
Gives you a frontend
No. Bring your own.
Yes: Next.js or Vite, plus an admin panel.
Gives you an admin
No. A tracing and request dashboard, which is a different thing.
Yes, generated from your resource definitions.
Infrastructure
Declared in code and provisioned for you.
A compose file and a deploy command. Yours to change.
Leaving
The business logic is ordinary Go. The wiring is not.
Nothing to leave: it wrote ordinary code into your repository.

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.