Go Backend Development for Mobile App

Go Backend Development for Mobile Applications

Go is chosen for mobile backends not out of fashion — but when REST API struggles above 5000+ concurrent connections and a Node.js monolith needs horizontal scaling every 200 rps. Goroutines and built-in scheduler handle thousands of connections on one instance without thread pool overhead, critical for push-heavy apps and streaming.

Why Go Instead of Node or Python Behind a Mobile Client

The mobile client is impatient. iOS closes URLSession in 60 seconds, Android OkHttp by default in 30. If backend slowly serves news list or user feed, client gets NSURLErrorTimedOut or SocketTimeoutException, not data.

Go solves specific pain points:

Latency under load. net/http handles each request in separate goroutine, costing ~2 KB memory vs ~1 MB per OS thread. During peak load (app launch after marketing campaign, mass pushes), server doesn't choke in thread queue.

Predictable GC. Since Go 1.14, GC pauses don't exceed 0.5 ms in most production scenarios — important when mobile client polls every 15 seconds and is sensitive to jitter.

Compiled binary without runtime. Docker image with Go service weighs 15–25 MB. Speeds cold start in Kubernetes on autoscaling — new pod starts in 2–3 seconds vs 20–30 for JVM apps.

How We Build API for Mobile Client

Core stack: Gin or Echo for HTTP routing, sqlx or pgx for PostgreSQL, go-redis for session caching and rate limiting, zap for structured logs.

For mobile client auth, implement JWT with refresh-token rotation: access token lives 15 min, refresh 30 days. When reissuing refresh token, invalidate old via Redis-set with TTL. Critical because mobile apps can't use httpOnly cookies as reliably as web — tokens live in Keychain/Keystore.

Real-world example: food delivery app with 80,000 DAU. Go API server (Echo v4) handled /orders/active endpoint — aggregating three PostgreSQL tables with JOINs. First Node.js version gave p99 = 450 ms at 500 rps. After Go migration with pgxpool connection pool and batch queries: p99 = 35 ms at same traffic. Infrastructure — same Kubernetes cluster, same two pods.

Project Structure

Follow layout from golang-standards/project-layout:

/cmd/api        — entry point, DI initialization
/internal       — business logic (handlers, services, repository)
/pkg            — reusable utilities
/migrations     — SQL migrations (goose or golang-migrate)

Repository layer as interfaces. Tests don't mock HTTP — only repository interface. Allows covering business logic with unit tests without spinning up DB.

Integrations Mobile Backend Needs

• Firebase Cloud Messaging — via official firebase-admin-go SDK, batch send up to 500 tokens at once
• Apple Push Notification Service — via apns2 with HTTP/2 connection pool, otherwise each push opens new TLS handshake
• S3-compatible storage (AWS S3, MinIO) — for user media, presigned URLs for direct client upload
• Stripe / CloudPayments — webhook handlers with idempotency key for safe retry

Process

Start with requirements audit: load profiles (rps, p99-latency SLA), third-party integrations, regulatory data storage. Then database schema and API contract design (OpenAPI 3.0). Development with key scenario tests (testing + testify). Deploy via Docker + Kubernetes, CI through GitHub Actions or GitLab CI.

Timeline depends on endpoint count and integrations: simple API (10–15 methods, one DB) — 3–5 weeks; service with realtime (WebSocket/SSE), multiple integrations and analytics — 8–14 weeks.

Common Mistakes on Go Mobile Backend

• No rate limiting at IP + user level — mobile client on bad connection retries in loop, without limits this kills DB
• database/sql without explicit SetMaxOpenConns — unlimited connection limit by default, on spike get connection refused from PostgreSQL
• Synchronous push send in HTTP handler — FCM/APNs respond in 200–500 ms, blocks goroutine and inflates latency; pushes via queue only (Redis Streams or RabbitMQ)
• Ignoring context.Context cancellation — on mobile client disconnect, DB request must cancel, else hanging transactions accumulate