Eat Better: Open-Source Full-Stack Boilerplate in 2026

What Is Eat Better?

Eat Better is one of the best Full-Stack Boilerplates tools for indie hackers and .NET/React developers shipping Dockerized apps. Built by ChristianJR19, Eat Better wires an ASP.NET Core backend, a Vite + React + TypeScript frontend, and a single-container Docker path into one repo, with local endpoints on 5265 and 5173. It is best understood as a starter application, not a framework: clone it, run it, and extend the codebase instead of assembling the stack from scratch.

Quick Overview

Who Should Use Eat Better?

• Solo founders building an MVP who want a working .NET API and React UI before they spend time on domain modeling.
• Full-stack C# developers who prefer ASP.NET Core over Node backends and want a typed frontend with TypeScript.
• Ops-minded teams deploying to Docker hosts such as Oracle Cloud and needing persistent data under /app/data.
• AI-assisted developers using an editor agent like Antigravity and wanting a repo layout that is easy to modify with file context.

Not ideal for:

• Teams that need authentication, billing, or roles already implemented.
• Projects that want a serverless or edge-first architecture.
• Apps that need a more explicit migration and database lifecycle story than the SQLite volume mount shown here.

Key Features of Eat Better

• Split runtime layout — The repo separates backend and frontend, which keeps the .NET API isolated from the Vite dev server and makes the build boundaries obvious. That is useful when debugging dependency issues because you can restart only the layer that changed.
• ASP.NET Core backend — The backend runs with dotnet run and listens on http://localhost:5265. That gives .NET developers a familiar Kestrel-driven local loop without custom process orchestration.
• Vite + React + TypeScript frontend — The UI starts with npm install and npm run dev on http://localhost:5173. Vite gives fast module reloads, and TypeScript keeps component props and API payloads from drifting apart as the app grows.
• Single-container Docker deployment — docker build -t eat-better-app . produces one image that contains both the backend and the frontend. That simplifies small-host deployments because you only manage one artifact, one port mapping, and one restart policy.
• Persistent SQLite storage — The deployment guide maps a host directory to /app/data and points ConnectionStrings__DefaultConnection at data/cms.db. That preserves application data across container restarts and makes local persistence predictable on a cheap VPS or cloud VM.
• Opinionated Oracle Cloud path — The Docker instructions map port 80 to container port 8080, which is the kind of minimal host setup that fits straightforward IaaS deployments. You do not need Kubernetes or a separate reverse proxy layer to get the app online.
• AI-assisted workflow — The guide explicitly documents Antigravity for chat, file context, terminal commands, and code refactors. That matters if you want to use a coding agent for repetitive CRUD work while keeping the repo structure simple enough for human review.

Eat Better vs Alternatives

Pick Claude Code Canvas if the repo already exists and you want a tighter editor loop for refactors, feature additions, and quick code generation. Pick OpenSwarm if you need a multi-agent workflow that can break a larger change into smaller execution steps.

Pick djevops if the project is already built and your main problem is deployment automation, environment management, or repeatable release steps. Eat Better sits earlier in the lifecycle than those tools: it gives you the app shape first, then you layer on editing or ops tooling as needed.

How Eat Better Works

Eat Better uses a two-process development model and a one-image deployment model. In local development, the backend is started from backend with dotnet run, while the frontend is started from frontend with npm run dev. That keeps the runtime responsibilities clear: ASP.NET Core handles API traffic, and Vite serves the React UI with TypeScript source files.

The deployment model is even simpler. The Docker image bundles both application parts, then persists data through a mounted host directory at /app/data and a SQLite connection string that points at data/cms.db. That is a pragmatic choice for small deployments because it avoids external database provisioning and keeps the state file visible to the operator.

# local development
cd eat-better/backend
 dotnet run

# second terminal
cd ../frontend
npm install
npm run dev

# containerized deployment
docker build -t eat-better-app .
mkdir -p ~/eat-better-data
docker run -d \
  --name eat-better \
  --restart unless-stopped \
  -p 80:8080 \
  -v ~/eat-better-data:/app/data \
  -e ConnectionStrings__DefaultConnection='Data Source=data/cms.db' \
  eat-better-app

The first block starts the app in development mode and exposes the two local servers the guide documents. The second block builds the combined image, creates a persistent host folder, and launches the container with a volume mount so the SQLite file survives restarts.

Eat Better's design is intentionally boring in the right places. It relies on standard .NET and Node toolchains instead of custom wrappers, which makes it easier to troubleshoot on macOS, Linux, or a cloud VM. If you prefer agent-assisted implementation while you extend the starter, the workflow pairs well with Claude Code Canvas for single-editor changes or OpenSwarm for larger coordinated refactors.

Pros and Cons of Eat Better

Pros:

• Fast path from clone to running app — You can start the backend and frontend with a handful of commands, which is ideal for early-stage product work.
• Clear backend/frontend boundary — ASP.NET Core and Vite live in separate directories, so dependency management stays predictable.
• Docker-first deployment story — The guide includes build and run commands, restart policy, port mapping, and a persistence volume.
• SQLite persistence with an explicit data mount — The ~/eat-better-data to /app/data mapping makes state management easy to reason about on small hosts.
• Type-safe UI layer — React plus TypeScript reduces avoidable prop and API shape errors in the frontend.
• Good fit for AI-assisted editing — The Antigravity workflow is practical when you want to delegate small implementation tasks and keep context local to open files.

Cons:

• No visible license in the scraped page text — You should verify repository licensing before using Eat Better in a commercial product.
• No tests or CI details are shown — The setup guide does not document automated testing, linting, or pipeline checks.
• SQLite may be too small for some production workloads — The persistence model is fine for low to moderate traffic, but not a substitute for a managed database at scale.
• The guide is setup-focused, not product-complete — You get the runtime and deployment shape, not authentication, billing, or admin features.
• Two local runtimes mean two failure modes — You need both the .NET SDK and Node/npm installed, so environment drift can happen on developer machines.

Getting Started with Eat Better

# prerequisites on macOS
brew install git node
# install the .NET 9 SDK from Microsoft, then verify
 dotnet --version
node -v
npm -v

# clone and run
git clone https://github.com/ChristianJR19/eat-better
cd eat-better/backend
dotnet run

# second terminal
cd ../frontend
npm install
npm run dev

After those commands, Eat Better should expose the backend on http://localhost:5265 and the frontend on http://localhost:5173. If you plan to run it in Docker later, the only extra step is to create a persistent host directory and pass the SQLite connection string exactly as shown in the deployment guide.

Verdict

Eat Better is the strongest option for a .NET + React starter when you want local development and Docker deployment from a single repo. Its main strength is the simple split between ASP.NET Core, Vite, and SQLite persistence. The caveat is that it is a bootstrap guide, not a mature product framework. Use it if you want a clean baseline, not prebuilt business logic.