Build a complete Go app on free tiers. 10 infrastructure layers — single binary hosting, Postgres via pgx, Redis, auth, storage, email, monitoring, CI/CD, background jobs, and API docs. Exact limits, growth costs.

The Complete Free Go/Golang Stack

Published 2026-04-03 · Not yet reviewed

Everything you need to build and ship a Go service — without spending a dollar. This guide recommends the best free tier for each layer of your Go infrastructure — 10 layers from single-binary hosting to API documentation — with exact limits for each. 11 of 28 figures in the tables below come from our records for 1,498 developer tools.

Designed for developers building REST APIs, CLI tools, microservices, DevOps tooling, and cloud-native infrastructure with Go. Each recommendation includes alternatives, a "when you'll outgrow it" guide, "why not X" callouts for popular-but-not-recommended options, and stability notes based on our tracking of 569 real pricing changes. The limits on this page were read from vendor pricing pages between 2026-08-11 and 2026-11-15.

$0/month
Total infrastructure cost for a Go service on free tiers
$0 covers the 5 of 9 picks whose free tier our own badge still reads as active. It does not cover Auth0 (stale), Sentry (stale), GitHub Actions (stale), swaggo/swag (unrated — page states no price).

📦 The Single Binary Advantage

Go compiles to a single, statically-linked binary. No runtime, no dependencies, no node_modules, no virtual environments. A Go Docker image built from scratch is typically 5-15 MB — vs 100+ MB for Node.js or Python. This means: lower memory usage (more headroom on free tiers), instant cold starts (50ms vs 5-30 seconds), simpler deploys (copy one file), and no supply chain attacks from dependency trees. Go is the language that Docker, Kubernetes, Terraform, and Prometheus are written in.

🔧 What Go's Standard Library Gives You for Free

Stack Overview

Layer Recommended Key Limit Stability
🚀 Hosting & Deployment Railway Free $0 per month. Start with a 30-day free trial with $5 credits, then $1 of free credit per month. Up to 1… active
🗄️ Database Neon Serverless Postgres with branching — free tier includes 100 CU-hours/month per project, 1 GB of Postgres… active
⚡ Cache & Redis Upstash Serverless Redis — 500K commands/month (250MB data). Vector: 200M vectors × dimensions and 10K queries a day… active
🔐 Authentication Auth0 Identity platform — 25K MAU (B2C), unlimited logins, social + database connections, Universal Login, 1… stale
📦 Object Storage Cloudflare R2 Object storage with zero egress fees — 10 GB storage, 1M writes, 10M reads/month free. Standard storage… active
✉️ Email & Transactional Resend Developer-first email API — 3K emails/month free (100/day cap), 3 domains, 1K marketing contacts/month, 5 AI… active
🐛 Monitoring & Observability Sentry Developer tier: 1 user, 5K errors/month, 5M spans/month, 50 session replays, 5GB application logs, 1GB… stale
⚙️ CI/CD GitHub Actions Free CI/CD for public repos (standard runners, unlimited minutes). Private repos on GitHub Free: $12 USD of… stale
⏱️ Background Jobs Go Goroutines Unlimited — built into Go runtime —
📖 API Documentation swaggo/swag Automatically generate RESTful API documentation with Swagger 2.0 for Go. Annotate your handler functions… not confirmed · page states no amount · 2026-10-15 unrated — page states no price

🚀 Hosting & Deployment

Recommended Railway Free active

Its Free plan opens with a 30-day trial carrying $5 of credits, then $1 of free credit a month, with auto-deploy from GitHub. Nixpacks auto-detects Go projects — compiles your binary and runs it. Railway does not put idle services to sleep unless Serverless is turned on. The Free plan gives $1 of credit a month. That pays for about 100 MB of RAM for a whole month at Railway's $10 per GB of RAM a month, before CPU. An always-on app that holds more than 100 MB uses more than $1. Go binaries start in milliseconds, so even serverless cold starts are negligible. Docker images from scratch base are typically 5-15 MB, maximizing the free credit.

Free $0 per month. Start with a 30-day free trial with $5 credits, then $1 of free credit per month. Up to 1 vCPU / 0.5 GB RAM per service. 0.5 GB of volume storage. 2 replicas during the free trial, then 1. Projects: 5…

When you'll outgrow it: You outgrow the Free plan when the app uses more than $1 of resources a month. Hobby costs $5 a month and includes $5 of usage, then charges only for usage beyond it. Render's free tier spins down after 15 minutes of inactivity, but Go's instant cold starts (~50ms) make this less painful than Python/Node. Fly.io has no free tier for new accounts (legacy accounts retain 3 shared VMs with 256 MB RAM). Koyeb has no free compute tier. Google Cloud Run's free tier (2M requests/month) is excellent for Go — instant scale-to-zero with near-instant cold starts.
⚠️ Why not Heroku: No free tier since November 2022. Why not Vercel: Vercel's Go support is limited to serverless functions — no persistent connections, WebSockets, or goroutines.
Full comparison guide →

🗄️ Database

Recommended Neon Free active

Serverless Postgres with the fastest Go driver. Free plan: 1 GB of storage and 100 CU-hours per project, up to 100 projects and 20 GB of storage in total, scales to zero after 5 minutes idle. Use with pgx — the fastest Go Postgres driver, written in pure Go with zero CGo dependencies. pgx supports connection pooling, prepared statements, COPY protocol, and native Go types (time.Time, net.IP, uuid.UUID). Neon's connection pooler handles high-concurrency goroutine access efficiently.

Serverless Postgres with branching — free tier includes 100 CU-hours/month per project, 1 GB of Postgres storage per project (20 GB total across all projects), 5 GB of public network transfer per project per month, up…

No longer a free-tier pick: CockroachDB — free tier removed.

When you'll outgrow it: When you exceed 1 GB of storage. Supabase offers 500 MB Postgres with built-in auth. Turso offers 5 GB of edge SQLite via libsql-go — great for read-heavy, globally distributed Go APIs.
⚠️ Why not SQLite (embedded): Go has excellent SQLite support via modernc.org/sqlite (pure Go, no CGo), but most free hosting uses ephemeral filesystems — your database is wiped on every deploy. Only viable on persistent VMs or with Litestream replication. Why not MySQL: Go's database/sql works with MySQL, but the Postgres ecosystem (pgx, sqlc, migrations) is stronger in Go. Most Go ORMs default to Postgres.
Full comparison guide →

⚡ Cache & Redis

Recommended Upstash Free active

Serverless Redis with Go support. Free tier: 500K commands/month, 250 MB of data. The go-redis/redis library is the standard Go Redis client — supports connection pooling, pipelining, pub/sub, and Lua scripting. Go's goroutines + Redis pub/sub is a natural fit for real-time features without external message brokers. Use for session storage, rate limiting, response caching, and as a task queue backend.

Serverless Redis — 500K commands/month (250MB data). Vector: 200M vectors × dimensions and 10K queries a day free. QStash: 1,000 messages/day free

  • Free Redis databases unused for at least 30 days are archived after warning emails. Their data is backed up and can be restored into a new database from the console. (From upstash.com/docs/redis/help/faq, read 2026-10-06.)
  • Adding the first payment method moves every free resource on the account to its paid plan: all Redis databases, plus QStash, Vector, Search and Blob. An account with a payment method cannot have free databases. (From upstash.com/docs/redis/overall/billing, read 2026-10-29.)
  • Paid databases do not get the Free plan's data and command allowance. (From upstash.com/pricing/redis, read 2026-10-29.)
  • Pay as You Go costs $0.20 per 100K commands. Storage past each database's first 1 GB is $0.25 per GB. Bandwidth past 200 GB a month is $0.03 per GB. (From upstash.com/pricing/redis, read 2026-10-29.)
  • A Pay as You Go database can have a monthly budget. When the budget is reached the database is rate-limited rather than continuing to bill. Budgets are set per database; there is no account-wide budget. (From upstash.com/docs/redis/overall/billing, read 2026-10-29.)
  • A free Upstash Redis database returns "ReplyError: ERR max requests limit exceeded" once it passes the monthly command limit. (From upstash.com/docs/redis/troubleshooting/max_requests_limit, read 2026-10-29.)
  • An agent can create an Upstash Redis database with no signup, card or API key by a POST request to upstash.com/start-redis. It is deleted after 3 days unless a person claims it from the console link in the response. (From upstash.com/pricing, read 2026-10-22.)

Also consider:

Redis Cloud Free active
When you'll outgrow it: When you exceed 500K commands/month. Redis Cloud offers 30 MB free with unlimited commands — better for high-throughput caching. For simple caching without Redis, Go's sync.Map or groupcache provide in-process caching with zero external dependencies, but these don't persist across deploys or share state between instances.

🔐 Authentication

Recommended Auth0 Free stale

25,000 MAU free — the most generous managed auth tier. Go has no framework-level auth (unlike Django), so you need an external provider or roll your own. Auth0's Go SDK + middleware pattern works cleanly: validate JWTs with go-jose or golang-jwt, wrap protected handlers with an auth middleware function. Go's crypto/bcrypt and crypto/subtle are in the standard library — if you roll your own, the crypto primitives are solid.

Identity platform — 25K MAU (B2C), unlimited logins, social + database connections, Universal Login, 1 Enterprise Connection, 5 Organizations, 1 Custom Domain. No credit card required

  • Using the Free plan's custom domain requires a valid credit card on file for verification and fraud prevention. Auth0 does not charge it. (From auth0.com/docs/customize/custom-domains, read 2026-10-08.)
When you'll outgrow it: When you exceed 25,000 MAU or need enterprise features. Clerk offers 50,000 MRU per app free with pre-built UI (less useful for API-only Go services). Supabase Auth gives 50,000 MAU if you're already using Supabase for your database. For API-only services, rolling your own with golang-jwt + bcrypt is viable — Go's stdlib makes the crypto parts safe.
⚠️ Why not rolling your own from scratch: Go's crypto stdlib (bcrypt, hmac, subtle) is excellent, making it tempting. But you'll still need to implement password reset flows, email verification, rate limiting, CSRF protection, and session management. Auth0 handles all of this on free tier. Only roll your own for API-key auth, internal services, or if you're already comfortable with the security implications.
Full comparison guide →

📦 Object Storage

Recommended Cloudflare R2 Free active

Zero egress fees — the standout differentiator. 10 GB storage, 1 million Class A operations, 10 million Class B operations per month. S3-compatible API via aws-sdk-go-v2. Go's io.Reader/io.Writer interfaces make streaming uploads and downloads natural — no buffering entire files in memory. Multipart uploads work out of the box with the AWS SDK.

Object storage with zero egress fees — 10 GB storage, 1M writes, 10M reads/month free. Standard storage beyond the free tier is $0.015 per GB-month, Class A operations $4.50 per million, Class B $0.36 per million…

When you'll outgrow it: When you exceed 10 GB storage. At scale, R2 saves dramatically vs S3: 1 TB stored + 10 TB egress costs ~$15/month on R2 vs ~$925/month on S3. Backblaze B2 offers 10 GB free and free egress up to 3x what you store, no CDN required. Supabase Storage gives 1 GB free. Image transformations require the Pro plan or above.
⚠️ Why not AWS S3: new accounts get no free storage, only Free plan credits that last at most 6 months; then storage costs $0.023/GB-month. Bandwidth is the part that does not expire — AWS S3 gives every account its first 100 GB of internet egress each month free, on an account of any age — so a Go service serving under 100 GB of pre-signed downloads a month pays nothing for egress on S3 either. Past that S3 charges $0.09/GB and R2 still charges $0.
Full comparison guide →

✉️ Email & Transactional

Recommended Resend Free active

Modern developer-first email API. 3,000 emails/month, 100/day on free tier. Clean REST API — call with net/http (stdlib) or any HTTP client. No framework-specific adapter needed. Go's net/smtp in the standard library handles basic SMTP sending, but API-based delivery (Resend, Postmark) is more reliable for production — handles SPF/DKIM/DMARC, bounce tracking, and deliverability monitoring.

Developer-first email API — 3K emails/month free (100/day cap), 3 domains, 1K marketing contacts/month, 5 AI credits, 30-day data retention

  • Until you verify a domain, Resend sends only from its resend.dev test domain, and only to the email address on your Resend account; mail to anyone else is refused with a 403 error. (From resend.com/docs/knowledge-base/403-error-resend-dev-domain, read 2026-10-20.)
  • Resend's free plan needs no credit card. (From resend.com/agents, read 2026-10-23.)
  • Resend launched Inboxes on October 22, 2026. "An inbox sends and receives email at an address on one of your domains." Every plan includes 3 Inboxes. Inboxes can be used by agents to receive tasks and updates. (From resend.com/blog/announcing-inboxes, read 2026-11-06.)
  • Broadcasts sent through the /broadcasts API or the dashboard do not count against the 3,000 transactional emails a month. Marketing plans are limited by contacts, not email volume. Emails sent or received through an inbox count towards the transactional emails quota. (From resend.com/pricing, read 2026-11-06.)

Also consider:

Brevo Free active
When you'll outgrow it: When you exceed 3,000 emails/month or 100/day. Brevo gives 300 emails/day (9,000/month) with marketing automation. Amazon SES has no free tier since AWS restructured its Free Tier on July 16, 2025, but at $0.10/1K it is the cheapest at scale.
⚠️ Why not SendGrid: Free tier removed May 2025. Many Go tutorials still reference SendGrid — those guides are outdated. Why not net/smtp alone: Go's stdlib SMTP works for dev/testing, but lacks bounce handling, deliverability monitoring, and template rendering that production email requires.
Full comparison guide →

🐛 Monitoring & Observability

Recommended Sentry Developer stale

Developer tier: 5,000 errors/month, 5M spans, 50 session replays, 1 GB attachments. Official Go SDK with HTTP middleware integration — captures panics, request context, and goroutine stack traces. Go also has excellent built-in observability: pprof (CPU/memory profiling), expvar (metrics), and net/http/pprof (live profiling endpoint). OpenTelemetry's Go SDK (otel-go) is mature — export traces to Grafana Cloud, Jaeger, or any OTLP-compatible backend.

Developer tier: 1 user, 5K errors/month, 5M spans/month, 50 session replays, 5GB application logs, 1GB attachments

When you'll outgrow it: When you exceed 5,000 errors/month or need more than 1 team member. Grafana Cloud offers 10,000 series metrics + 50 GB logs + 50 GB traces — great for full observability with OpenTelemetry. BetterStack combines uptime monitoring (10 monitors) with incident management.
⚠️ Why not Datadog: Free tier has only 1-day metric retention — practically unusable for debugging. Per-host pricing ($15/host/month) gets expensive fast. Why not just pprof: pprof is excellent for development profiling but doesn't capture production errors, alerting, or request tracing across services. Use both — pprof for profiling, Sentry for errors.
Full comparison guide →

⚙️ CI/CD

Recommended GitHub Actions Free stale

2,000 minutes/month on free tier for public repos (unlimited) and private repos. Go tests are fast — the testing package is in the standard library, no test framework needed. go test ./... runs everything. Matrix testing across Go 1.21-1.23 catches compatibility issues. Caching the Go module cache cuts CI time by 60-80%. Add go vet, staticcheck, and golangci-lint for comprehensive static analysis — Go's tooling is best-in-class.

Free CI/CD for public repos (standard runners, unlimited minutes). Private repos on GitHub Free: $12 USD of included compute a month, which is 2,000 minutes on a standard Linux runner ($0.006/min), 1,200 on Windows…

Also consider:

Render Hobby active
When you'll outgrow it: When you exceed 2,000 minutes/month on private repos. Go's fast compilation means CI runs are typically shorter than Python/Node projects. Railway and Render auto-deploy from git with zero CI config — combine with GitHub Actions for tests only.
Full comparison guide →

⏱️ Background Jobs

Recommended Go Goroutines Free (built into Go)

Go's killer feature — goroutines handle most background task needs natively, with zero external dependencies. Launch a goroutine for fire-and-forget work (sending emails, logging, webhooks) at near-zero cost (~2 KB per goroutine). For persistent queues that survive restarts, use Asynq (Redis-backed, inspired by Ruby's Sidekiq) or Temporal (durable workflow orchestration, free tier available). Upstash Redis (500K commands a month free) works as the Asynq backend.

Unlimited — goroutines cost ~2 KB each, millions per process

Also consider:

Upstash Free active
When you'll outgrow it: Goroutines never outgrow — they scale to millions. You need a persistent queue (Asynq, Temporal, NATS JetStream) when tasks must survive process restarts, need scheduling, or require exactly-once delivery. Upstash's 500K commands/month covers moderate Asynq usage. Redis Cloud's 30 MB free with unlimited commands is better for high-throughput queues.
⚠️ Why not Celery/Bull/Sidekiq equivalents: Go doesn't need them for most use cases — goroutines handle concurrent work natively. Asynq is the closest Go equivalent when you need persistence. Why not channels alone: Go channels are in-process — tasks are lost if the process crashes. For production reliability, use a Redis-backed queue.

📖 API Documentation

Recommended swaggo/swag Free (open source) unrated — page states no price

Generate OpenAPI/Swagger documentation from Go comments. Add annotations to your handler functions, run swag init, and get a Swagger UI endpoint. Works with chi, gin, echo, fiber, and net/http. Not as automatic as FastAPI's type-driven docs, but integrates well with Go's existing comment conventions. For gRPC services, buf and Connect provide automatic documentation from .proto files.

Automatically generate RESTful API documentation with Swagger 2.0 for Go. Annotate your handler functions, run swag init, and get a Swagger UI endpoint; works with chi, gin, echo, fiber and net/http. Free and… not confirmed · page states no amount · 2026-10-15

When you'll outgrow it: You won't outgrow swaggo — it scales with your API. For API gateway features (rate limiting, API keys, analytics), Zuplo offers a free tier with 500K requests/month. For gRPC, buf.build's free tier generates client SDKs and documentation from your proto definitions.
⚠️ Why not hand-writing OpenAPI YAML: It drifts from your actual code. swaggo generates from your source — one source of truth. Why not no docs at all: Even for internal APIs, Swagger UI saves debugging time.

Stability Notes

Recent pricing changes affecting vendors in this stack. Based on our tracking of 569 deal changes across 1,498+ developer tools.

limits increased Neon: Neon raised the Free plan's Postgres storage from 0.5 GB to 1 GB per project and added a limit of 20 GB across all of an account's projects. Source ↗
pricing restructured Fly.io: Fly.io raised the price of memory on Machines to $6.00 per GB a month, from about $5, and left CPU prices unchanged. Every preset include... Source ↗
new free tier Railway: Railway added a free VM accessible via `ssh railway.new` with no account or credit card needed. Each VM has 2 vCPU / 2 GB, preinstalled c... Source ↗
free tier removed CockroachDB: CockroachDB stopped offering its free Basic plan (50 million RUs and 10 GiB of storage free per month) to new deployments on 2026-09-15, ... Source ↗
pricing restructured Backblaze B2: On May 1, 2026 Backblaze raised B2 pay-as-you-go storage from $6 to $6.95 per TB a month and made Class B and Class C API calls free; the... Source ↗
pricing restructured Render: Render replaced its workspace plans. Bandwidth for the Hobby tier went from 100 GB to 5 GB included per month, then $0.15 per GB, and Hob... Source ↗
limits reduced Grafana Cloud: On 2026-04-20, Grafana Cloud restricted new Free and Trial accounts. Email alerts and reports can only go to users of their own Grafana i... Source ↗
limits reduced Grafana Cloud: On 2026-04-07, Grafana Cloud introduced a hard limit of 1,000 dashboards and 1,000 folders per free tier stack. Stacks already above thes... Source ↗
limits increased Neon: Neon's Free plan went from one member per organization to unlimited members. Source ↗
free tier removed Koyeb: Koyeb withdrew its free Starter plan from new users after announcing on 2026-02-17 that it is joining Mistral AI: new users "must subscri... Source ↗
pricing restructured Fly.io: From January 2026 Fly.io bills volume snapshot storage at $0.08/GB a month after the first 10 GB free each month; automatic snapshots wer... Source ↗
limits increased Neon: Neon raised the Free plan's project limit from 80 to 100, the last of seven increases since 2025-08-29, when the limit was 10. Source ↗

View all 569 pricing changes →

The First Paid Upgrade — What to Spend First

When you're ready to spend your first dollar, here's where it matters most. Sorted by which limits you'll likely hit first:

Layer Free Limit First Paid Plan What You Get
Database ⬆ hit first 1 GB storage per project Launch, usage-based $0.106/CU-hour, $0.35/GB-month, autoscaling up to 16 CU
Hosting ⬆ hit first $1 of free credit a month after 30-day $5 trial Hobby $5/mo $5 of usage included, no sleep, more RAM
Cache/Redis 500K cmds/mo Pay-as-you-go $0.2/100K Unlimited commands, 1 GB storage
Auth 25,000 MAU Essential $35/mo Custom domains, roles, MFA policies
Email 3,000 emails/mo Pro $20/mo 50,000 emails/mo, custom domains, analytics
Storage 10 GB $0.015/GB/mo Unlimited storage, still zero egress
Monitoring 5,000 errors/mo Team $26/mo 50,000 errors, unlimited members, integrations
Background Jobs Unlimited Free forever N/A — built into Go runtime
API Docs Unlimited Free forever N/A — open source
CI/CD 2,000 min/mo Team $4/user/mo 3,000 min/mo, required reviewers

The first paid upgrade: Database (Neon Launch, usage-based, no monthly minimum) is the first upgrade that matters — storage beyond 1 GB at $0.35/GB-month and autoscaling up to 16 CU. Two layers — background jobs (goroutines) and API docs (swaggo) — are free forever with no external service. Everything else — auth (25K MAU on Auth0), email (3K/mo), monitoring (5K errors), cache/Redis (500K cmds/mo), storage (10 GB R2), CI (2,000 min) — stays free well past your first 1,000 users. Go's minimal resource footprint means you get more out of every free tier.

Architecture: How It Fits Together

A typical Go service connects these layers:

Client → Railway (Go binary, net/http or chi router) → Neon (Postgres via pgx) → Auth0 (JWT validation via middleware) → Upstash Redis (cache via go-redis) → R2 (file storage via aws-sdk-go-v2) → Resend (transactional emails via net/http) → goroutines (background tasks, in-process) → Sentry (error tracking + HTTP middleware) → swaggo/swag (/swagger/index.html) GitHub → GitHub Actions (CI: go test + golangci-lint) → Railway (CD: auto-deploy)

All connections use HTTPS — no VPCs, no SSH tunnels, no complex networking. Each service is independently replaceable. Go's interface-based design makes swapping providers clean — implement the interface, swap the implementation.

Need a different framework? See our Free Next.js Stack for React full-stack, Free Django Stack for batteries-included Python, Free FastAPI Stack for async Python APIs, Free Startup Stack for framework-agnostic infrastructure, Free AI Stack for ML/AI development, or Free DevOps Stack for infrastructure tooling (mostly written in Go). Or search our full index of 1,498+ developer deals.