Deploy Go App with Database Free

TL;DR — Deploy a Go app with a managed PostgreSQL database on RaidFrame for $0. Go developers have fewer free hosting options than Node.js or Python devs. RaidFrame runs any Docker container — Go compiles to a tiny binary, making it perfect for container deployment.

The Go hosting problem

Go developers are underserved by hosting platforms. A 90+ comment Reddit thread asks: "Is it possible to host a Golang application free indefinitely?"

Most answers: "Use Google Cloud Run" (complex), "Try Fly.io" (no free tier anymore), or "Buy a refurbished mini PC for €100" (seriously).

The issue: platforms like Vercel, Netlify, and Cloudflare Pages are built for JavaScript. Go doesn't fit their serverless model. You need container hosting — and most container platforms charge from day one.

RaidFrame runs Docker containers for free. Go compiles to a ~10MB binary. A Go app on RaidFrame uses less resources than a Node.js app, and you get a managed database alongside it.

Prerequisites

• Go 1.22+ installed
• A GitHub account
• A RaidFrame account (sign up free)

Step 1: Create a Go API

mkdir my-go-api && cd my-go-api
go mod init github.com/yourname/my-go-api

Install dependencies:

go get github.com/gin-gonic/gin
go get github.com/jackc/pgx/v5
go get github.com/jackc/pgx/v5/pgxpool

Step 2: Write the server

Create main.go:

package main
 
import (
    "context"
    "log"
    "net/http"
    "os"
 
    "github.com/gin-gonic/gin"
    "github.com/jackc/pgx/v5/pgxpool"
)
 
var db *pgxpool.Pool
 
func main() {
    var err error
    db, err = pgxpool.New(context.Background(), os.Getenv("DATABASE_URL"))
    if err != nil {
        log.Fatal("Unable to connect to database:", err)
    }
    defer db.Close()
 
    // Create table if not exists
    db.Exec(context.Background(), `
        CREATE TABLE IF NOT EXISTS users (
            id SERIAL PRIMARY KEY,
            email TEXT UNIQUE NOT NULL,
            name TEXT,
            created_at TIMESTAMPTZ DEFAULT NOW()
        )
    `)
 
    r := gin.Default()
 
    r.GET("/health", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"status": "ok"})
    })
 
    r.GET("/users", func(c *gin.Context) {
        rows, _ := db.Query(context.Background(), "SELECT id, email, name FROM users")
        defer rows.Close()
 
        var users []gin.H
        for rows.Next() {
            var id int
            var email, name string
            rows.Scan(&id, &email, &name)
            users = append(users, gin.H{"id": id, "email": email, "name": name})
        }
        c.JSON(http.StatusOK, users)
    })
 
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }
    r.Run(":" + port)
}

Step 3: Add a Dockerfile

# Build stage
FROM golang:1.22-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o server .
 
# Run stage
FROM alpine:3.19
WORKDIR /app
COPY --from=builder /app/server .
EXPOSE 8080
CMD ["./server"]

Multi-stage build: the final image is ~15MB. Compare that to a Node.js image at 200MB+.

Step 4: Deploy

rf login
rf init
rf deploy

Your Go API is live with a managed PostgreSQL database. The DATABASE_URL environment variable is set automatically.

curl https://my-go-api.raidframe.app/health
# {"status":"ok"}

Why Go on RaidFrame?

Can I use other Go frameworks?

Yes. RaidFrame runs any Docker container. Use whatever framework you prefer:

// Gin
r := gin.Default()
 
// Chi
r := chi.NewRouter()
 
// Fiber
app := fiber.New()
 
// Echo
e := echo.New()
 
// Standard library
http.ListenAndServe(":8080", mux)

FAQ

Does RaidFrame support Go natively?

RaidFrame runs Docker containers. Go's official Docker image works perfectly. The multi-stage build produces a minimal Alpine image.

Can I use SQLite with Go on RaidFrame?

Yes, but we recommend PostgreSQL for production. Go's database/sql works with both. The free managed PostgreSQL is more reliable than file-based SQLite in a container.

How do I add environment variables?

rf env set API_KEY your-secret-key
rf env set GIN_MODE release

Is Gin the best Go framework for APIs?

Gin is the most popular, but Chi and standard library net/http are excellent choices. For maximum performance, use net/http directly — Go's standard library is production-grade.

How do I run database migrations?

Use a migration tool like goose or golang-migrate:

rf run "goose -dir migrations postgres $DATABASE_URL up"

What's next?

• Scale your PostgreSQL database
• Add Redis caching to your Go API
• Set up CI/CD for automated deploys

Deploy your Go app with a database for free — start now.