The 2026 Indie Hacker Stack: Claude Code, MCP, and Hetzner

Stack Overview

With this stack, solo founders and indie developers ship full-featured web applications without venture funding, zero managed services bloat, and complete control over their infrastructure.

The 2026 indie stack consists of:

• Claude Code — AI-powered development environment for writing and refactoring code
• MCP Servers — ecosystem connectors for GitHub, databases, and APIs
• Hetzner — ultra-cheap Linux VMs (€2.99–9.99/month before April 2026)
• GitHub — version control, CI/CD, and issue tracking
• SQLite or PostgreSQL — persistent data layer

What makes this combination work: Claude Code removes the tedious boilerplate and refactoring friction that kills solo momentum. MCP servers let Claude understand your codebase and infrastructure in real time without manual context switching. Hetzner keeps costs near zero. GitHub provides free CI/CD for public projects. And SQLite (with Litestream backup) eliminates operational overhead while staying production-ready.

The problem this solves: Indie developers have historically chosen between (a) expensive managed platforms like Vercel+Supabase ($50–100/month minimum), (b) pure DIY with raw Linux (high operational burden), or (c) no AI assistance (slower shipping). This stack splits the difference — you get Claude Code’s productivity gains with infrastructure costs below $30/month and reasonable operational simplicity.

graph TB
    A["Claude Code<br/>(AI Dev)"] -->|MCP| B["GitHub<br/>(Version Control)"]
    A -->|MCP| C["SQLite/PostgreSQL<br/>(Data)"]
    A -->|SSH| D["Hetzner VM<br/>(Linux)"]
    B -->|CI/CD| D
    C -->|Litestream| E["AWS S3<br/>(Backup)"]
    D -->|Hosts| F["Web App"]

---

Components

Claude Code (Pro or Max)

Claude Code is an AI-powered development environment that understands your codebase, executes bash commands, reads/writes files, and refactors code across multiple files. It’s available on macOS, Linux, and Windows.

Why in this stack:

• Eliminates boilerplate writing and tedious refactoring — the biggest time-killer for solo devs
• Integrates MCP servers to understand your GitHub issues and database schema without manual context pasting
• Works offline (local models coming soon) and respects your privacy — no code shipped to cloud by default

Tool	Difference	Switch if
Claude Code Pro ($20/month)	~44k tokens/5 hours; reset cycle every 5–8 hours; good for feature development and bug fixes	Building simple CRUD apps, personal projects
Claude Code Max ($100/month)	~88–220k tokens/week; continuous usage without resets; necessary for large refactoring runs	Heavy AI-assisted development, complex architecture changes
Cursor ($20/month)	Closed-source VS Code fork; less capable at large-scale planning; strong at completion-based edits	Prefer VS Code UI over a dedicated app
GitHub Copilot Chat ($20/month)	Limited to VS Code; no file editing, only completions; requires manual prompt engineering	Only need autocomplete, not agentic coding

Fair warning: Pro plan users frequently hit token limits during heavy refactoring sessions (January 2026 saw complaints about 60% effective reduction after a temporary holiday bonus expired). Max plan is better for sustained development.

---

MCP Servers (Open Ecosystem)

MCP (Model Context Protocol) is Anthropic’s open standard for connecting Claude to external services—GitHub, databases, APIs, and workflows. There are 1,864+ production MCP servers available; most are free and open source.

Why in this stack:

• GitHub MCP lets Claude read issues, create PRs, and check CI status without leaving Claude Code
• Database MCP (PostgreSQL/SQLite) gives Claude live access to your schema and query results
• Reduces context-switching friction — no more copying issue text or running manual SQL queries

Server Type	Capability	Gotchas
GitHub MCP (Anthropic-maintained)	Read issues, create draft PRs, check CI status	Can’t create issues directly—returns draft only; token management required
Database MCP (multiple)	Execute queries, inspect schema, fetch data	Requires correct permissions; need to pass connection string securely
Stdio MCP (local)	Run custom scripts, integrate your own tools	Windows requires cmd /c wrapper for npx; fragile
HTTP MCP (remote)	Cloud-based servers with OAuth 2.0 support	HTTP transport had regressions in early 2026; authorization headers sometimes not sent

Setup reality: Expect 1–2 hours for initial configuration. Documentation is fragmented across GitHub repos, Anthropic blogs, and community posts. Silent failures are common (“Connection closed” with no debugging info). Highly recommended: save working configs in version control and automate setup via .mcp.json.

---

Hetzner Cloud VMs (CX23 or CAX21)

Hetzner Cloud provides raw Linux VMs in data centers across Europe and US regions. Pricing is lowest in the industry: €2.99–9.99/month for 2–4 vCPU machines with 4–8GB RAM.

Why in this stack:

• Eliminates managed service vendor lock-in (no Vercel, Supabase, Railway bills)
• Extreme cost transparency — you pay only for compute, traffic within region, and backups
• All-inclusive pricing: DDoS protection, Cloud Firewall, and IPv4/IPv6 included

Provider	Entry Tier	Bandwidth	Best For	Catch
Hetzner CX23 (€2.99→€3.99/month Apr 2026)	2 vCPU, 4GB RAM, 40GB SSD	20TB/month EU, 1TB/month US	MVP, bootstrap-first projects	Limited to single-region, no managed backups
DigitalOcean Basic ($24/month)	1 vCPU, 1GB RAM equivalent	Metered overage charges	Managed databases, CDN, strong docs	8× Hetzner’s cost for same specs
Linode (~$5–9/month)	1 vCPU, 1GB RAM	Metered	Better 24/7 support, distributed infrastructure	Enterprise-focused; less indie community
AWS EC2 (t3.micro free tier then $4+/month)	1 vCPU, 1GB RAM	Expensive egress ($0.02/GB)	Existing AWS ecosystem	Egress costs kill indie margins; complex pricing
Vercel Edge Functions	Serverless	Bundled	Next.js optimized deployments	Not suitable for long-running processes; vendor lock-in

Price increase alert: April 1, 2026, Hetzner raised prices 20–37% across tiers (DRAM prices up 171% YoY). CX23 goes from €2.99 to €3.99/month. No grandfather pricing—existing customers get the increase.

---

GitHub (Free)

GitHub hosts your code, runs CI/CD pipelines, and tracks issues. Free tier includes unlimited public and private repositories.

Why in this stack:

• Completely free CI/CD for public repos (unlimited GitHub Actions minutes)
• Private repos get 2,000 CI/CD minutes/month free (enough for most indie projects)
• MCP integration via official GitHub MCP server

Platform	Minutes/Month	Price	Notes
GitHub Actions (free tier)	Unlimited (public) / 2,000 (private)	$0	Fastest for indie projects; Linux runners ~39% cheaper since 2026 update
GitHub Actions (self-hosted)	Billable from March 2026	$0.002/minute	Erodes DIY appeal; only worth it for heavy CI/CD
GitLab CI/CD (free tier)	400 minutes/month	$0	Less generous than GitHub; self-hosted option available
CircleCI	6,000 minutes/month	$0	Generous free tier but smaller community

Unspoken rule: Most indie hackers keep projects public to get unlimited CI/CD minutes. Private repos are fine for hobby projects staying under 2,000 minutes/month (roughly 10–15 deployments per day).

---

SQLite + Litestream (or PostgreSQL on Hetzner)

Data persistence layer. Two viable paths for indie projects:

Path 1: SQLite + Litestream (recommended for first-time shippers)

• SQLite database runs on your Hetzner VM (file-based, zero operational overhead)
• Litestream streams WAL (Write-Ahead Log) updates to AWS S3 in real time
• On server failure: restore from S3 snapshot to any point in time
• Costs: $0 (using AWS S3 free tier for backups up to ~5GB)

Path 2: PostgreSQL on Hetzner DIY (for teams or high-concurrency projects)

• Postgres runs in Docker on same Hetzner VM (or separate VM if needed)
• Manual backups via pg_dump cron jobs
• More operational knowledge required (replication, monitoring, failover)
• Costs: $5–9/month (VM only, if using Docker self-hosted)

Why SQLite changed the indie game in 2026:

• Rails 8 shipped SQLite-first by default (January 2025)
• Litestream simplified backups (no more pg_dump chaos)
• Turso (hosted SQLite edge database) offers free tier: 9GB storage, global read replicas

Option	Setup Time	Ops Overhead	Concurrent Writers	Cost	Best For
SQLite + Litestream	1–2 hours	None (S3 handles backups)	Single writer (WAL mode helps)	$0–5/month	MVP launch, solo dev, <500 DAU
PostgreSQL DIY (Hetzner)	4–8 hours	Moderate (backup cron, monitoring)	Thousands/sec	$5–9/month	Team projects, high write concurrency
Supabase free tier	30 minutes	None (managed)	Limited	$0 (first year, then $5–15/month)	Quick prototypes, limited timeline
Turso (hosted SQLite)	30 minutes	None (managed)	Single primary	Free tier 9GB, then pay-as-you-go	Global read replicas, zero-downtime migrations
Firebase / Firestore	15 minutes	None (managed)	Cloud-based	Free tier 1GB, then $5+/month	Real-time sync, serverless, lock-in risk

---

Setup Walkthrough

Step 1: Rent a Hetzner VM

Create a Hetzner Cloud account, then provision a CX23 or CAX21 (ARM is cheaper: €4.99/month).

# Via Hetzner dashboard or CLI
hcloud server create \
  --name indie-app \
  --type cx23 \
  --image ubuntu-22.04 \
  --location fsn1
# Returns: Server IP (e.g., 192.0.2.100)

Record the IP address. SSH into it and update the system.

ssh root@192.0.2.100
apt update && apt upgrade -y

---

Step 2: Install Docker and Set Up SQLite

Install Docker for containerized deployments (optional but recommended). Then create a directory for your app and initialize SQLite.

# Install Docker
curl -fsSL https://get.docker.com -o get-docker.sh && sh get-docker.sh

# Create app directory
mkdir -p /app/data
cd /app

# Initialize SQLite
sqlite3 /app/data/app.db "SELECT 1;" # Creates empty DB

If using PostgreSQL instead, run:

# Docker PostgreSQL (alternative to SQLite)
docker run -d \
  --name postgres \
  -e POSTGRES_PASSWORD=your_secure_password \
  -v /app/data:/var/lib/postgresql/data \
  -p 5432:5432 \
  postgres:16

---

Step 3: Deploy Your App

Clone your GitHub repository and start your app (example: Node.js with npm).

cd /app
git clone https://github.com/yourname/your-app.git
cd your-app
npm install
npm run build
npm run start

For Django, Rails, or other frameworks, adjust the build and start commands accordingly.

---

Step 4: Set Up Litestream Backup (SQLite Only)

If using SQLite, install Litestream to stream backups to AWS S3.

# Download and install Litestream (check latest at https://github.com/benbjohnson/litestream/releases)
wget https://github.com/benbjohnson/litestream/releases/download/v0.3.13/litestream-v0.3.13-linux-amd64.tar.gz
tar xzf litestream-v0.3.13-linux-amd64.tar.gz -C /usr/local/bin/

# Create Litestream config
cat > /etc/litestream.yml << 'EOF'
dbs:
  - path: /app/data/app.db
    replicas:
      - type: s3
        bucket: your-backup-bucket
        path: app.db
        region: us-east-1
        access-key-id: YOUR_AWS_KEY
        secret-access-key: YOUR_AWS_SECRET
EOF

# Start Litestream daemon
litestream replicate -config /etc/litestream.yml &

Store AWS credentials in environment variables (.env) not in config files.

---

Step 5: Configure MCP for GitHub

In Claude Code on your local machine, add the GitHub MCP server to access repositories and issues.

Follow the official GitHub MCP setup at https://github.com/anthropics/mcp-github. Add your Personal Access Token as an environment variable:

# Set your GitHub PAT as an environment variable
export GITHUB_TOKEN=your_github_pat_here

# Test the connection
claude mcp test github

Then in your .mcp.json (project root), define GitHub access:

{
  "mcpServers": {
    "github": {
      "command": "node",
      "args": ["node_modules/.bin/github-mcp"],
      "env": {
        "GITHUB_TOKEN": "YOUR_GITHUB_PAT"
      }
    }
  }
}

Use a Personal Access Token (PAT) from GitHub Settings > Developer settings > Personal access tokens. Scope: repo, workflow, read:issues.

---

Step 6: Configure MCP for Your Database

Add database MCP so Claude Code can inspect your schema and run queries during development.

# For SQLite (local stdio server)
claude mcp add --transport stdio db -- npx -y @bytebase/dbhub --dsn "sqlite:////app/data/app.db"

# For PostgreSQL (HTTP server)
claude mcp add --transport http postgres https://dbhub.your-domain.com/api/mcp

Test the connection by asking Claude Code: “Show me the database schema.”

---

Step 7: Set Up GitHub Actions CI/CD

Create a GitHub Actions workflow to test and deploy on every push.

# .github/workflows/deploy.yml
name: Deploy

on:
  push:
    branches:
      - main

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run tests
        run: npm test

  deploy:
    needs: test
    runs-on: ubuntu-latest
    if: success()
    steps:
      - uses: actions/checkout@v4
      - name: Deploy via SSH
        uses: appleboy/ssh-action@master
        with:
          host: 192.0.2.100
          username: root
          key: ${{ secrets.DEPLOY_KEY }}
          script: |
            cd /app/your-app
            git pull origin main
            npm run build
            npm run start

Generate a deploy SSH key on your Hetzner VM and add it to GitHub Secrets as DEPLOY_KEY.

---

Step 8: Set Up SSL/HTTPS

Install Certbot and auto-renew Let’s Encrypt certificates.

apt install certbot python3-certbot-nginx -y

# Generate certificate (replace your-domain.com)
certbot certonly --standalone -d your-domain.com

# Set up auto-renewal cron
echo "0 3 * * * certbot renew --quiet" | crontab -

---

Pricing

Component	License	Free Tier	Paid From	Note
Claude Code Pro	Proprietary	Limited access (no Code)	$20/month	44k tokens/5 hours; adequate for steady development
Claude Code Max	Proprietary	—	$100/month	220k tokens/week; required for heavy refactoring
MCP Servers	Open source (mostly)	1,864+ free servers	$0+	GitHub MCP free; custom servers free if self-hosted
Hetzner CX23	Pay-as-you-go	No free tier	€3.99/month (after Apr 1, 2026)	Includes all traffic within EU region, DDoS protection
PostgreSQL DIY	Open source	Self-hosted free	$0 (on Hetzner)	Only costs if separate VM (€2.99+)
SQLite + Litestream	Open source	Both free	$0 (S3 backups via AWS free tier)	Free tier covers ~5GB backups; then ~$0.12/month per additional GB
GitHub	Proprietary	Unlimited repos, 2k CI/CD min/month (private)	$4/user/month (Team)	Public repos = unlimited CI/CD
Domain	DNS registrar varies	—	$10–15/year (~$1/month)	Cheap on Namecheap, Porkbun

Total monthly cost for MVP stack (2026 prices):

• Claude Code Pro: $20
• Hetzner CX23: €3.99 (~$4.65)
• Domain: ~$1
• S3 backups: $0 (free tier)
• Total: ~$25.65/month

For sustained heavy development:

• Claude Code Max: $100
• Hetzner CAX21 (ARM): €4.99 (~$5.82)
• PostgreSQL managed (e.g., Supabase): $5–15/month
• GitHub Actions (if self-hosted heavy use): $0–20/month
• Total: ~$130–180/month

---

When to Use This Stack

✓ Solo founder shipping an MVP — You control all decisions, iterate fast, and minimize burn rate. ✓ Bootstrapped SaaS or tool — No venture funding means every dollar matters; this stack is cost-optimized. ✓ Personal project with future scale — SQLite + Litestream works for hundreds of DAU; easy to migrate to PostgreSQL later. ✓ You prefer ownership over convenience — No vendor lock-in (Vercel, Supabase, etc.). You own your code and infrastructure. ✓ You already use Claude Code — Natural extension; no new tool friction. ✓ Development speed matters more than ops expertise — Claude Code removes boilerplate; focus on product, not servers.

---

When NOT to Use This Stack

✗ High-concurrency writes — SQLite single-writer bottleneck becomes painful above ~1000 writes/sec. Use PostgreSQL multi-node or managed database. ✗ Team of 3+ engineers — Raw VPS management is friction; Vercel + Supabase or Heroku better for teams that need managed infrastructure. ✗ You need visual/managed database UI — DIY PostgreSQL on Hetzner has no UI; Supabase or Vercel Postgres offer dashboards. ✗ Serverless-first architecture — Claude Code + Hetzner VM assumes long-running processes. AWS Lambda + DynamoDB is a different paradigm. ✗ Global latency-critical app — Hetzner single-region (EU strong, US weak). AWS/Cloudflare for geo-distributed edge deployments. ✗ Your app writes frequently to the same table — SQLite’s single-writer model breaks down under concurrent bulk inserts; PostgreSQL required. ✗ MCP config fragility — Configuration breaks after Claude Code updates; requires manual troubleshooting and repair. ✗ You hate DevOps — Even simple MCP setup takes 1–2 hours. Hetzner VM requires manual backups, security patching, monitoring. Vercel abstracts all this away (at higher cost).