Production-ready Go services for companies that need stable p99 latency, no-surprises autoscaling and real observability from day one. 100% senior in-house team.
It is the language of modern cloud for a reason: same binary in local, in CI and in production. No GIL, no runtime warmup, no heavy async frameworks. Here is how we apply it.
<100 ms
Typical Cloud Run cold-start with an optimised Go binary
<30 MB
Final Docker image with multi-stage build
0 → N
Transparent autoscaling, €0 cost when idle
100%
Senior in-house team. Zero subcontractors
Why Go
We do not sell Go because it is fashionable. We pick it when it cuts ops cost, improves the SLA or simplifies the system's mental model. Here is the concrete why.
No GIL, no runtime warmup, no prohibitive cold-start on Cloud Run. A Go binary boots in <100 ms and keeps a stable p99 at high concurrency. What in Node or Python requires constant tuning is the default in Go.
Fanning out to multiple external APIs (Claude, Stripe, BigQuery) in parallel is trivial: one goroutine per call, a sync.WaitGroup, an errgroup.Group with cancellation. No event loops, no async/await, no heavy async frameworks.
Final Docker image under 30 MB with a multi-stage build. Zero runtime dependencies, zero compatibility hell. Cloud Run 0→N autoscaling is transparent, idle-instance cost = €0.
The Go compiler catches errors that ship to production in Python or JavaScript. Internal APIs with typed structs, explicit error handling, race detector in tests. Fewer bugs, fewer PagerDuty alerts.
Official OpenTelemetry SDK, HTTP / gRPC / SQL instrumentation out-of-the-box, structured logging with slog (Go 1.21+), pprof for production profiling. No patching ecosystems like Node.
Go is the language of modern cloud: Kubernetes, Docker, Terraform, etcd, Prometheus, Grafana — all written in Go. Official GCP, AWS and Azure libraries have first-class support. Cloud Run, Pub/Sub and Spanner integration is natural.
Stack and choices
Decisions made in real production. No fashion-driven frameworks, no abstractions the customer pays for when they break.
Layer
HTTP / API
chi · echo · fiber
chi for idiomatic routers and native net/http middleware. echo or fiber when you want more batteries-included (binding, validators). We avoid heavy frameworks like Beego.
Persistence
pgx · sqlc · ent
pgx for raw Postgres (zero ORM overhead). sqlc to generate typed code from real SQL. ent when the domain warrants an ORM with declarative migrations.
Messaging
Pub/Sub · NATS · Kafka
Pub/Sub for native GCP integration. NATS when you need <1 ms latency without lock-in. Kafka only if you already have a platform team running it.
Observability
OpenTelemetry · slog · pprof
OTel for tracing, metrics and structured logs, exported to Cloud Trace, Datadog or Grafana. slog (Go 1.21+) as the standard logger. Always-on pprof for reactive profiling.
Testing
testify · gomock · go-test-deep
Table-driven tests with testify/assert. Mocks generated with mockgen. Race detector active in CI. Integration tests against real Postgres with testcontainers-go.
Deployment
Cloud Run · GKE · Terraform
Cloud Run for stateless HTTP/gRPC services with autoscaling. GKE when there are sidecars, complex cron jobs or stateful workloads. Terraform for anything touching infra — no console clicks.
Use cases
Services that scale to millions of requests, sub-second latency, mature observability and predictable operations.
Go services that orchestrate LLM calls (Claude, OpenAI), function tools over a data warehouse and persistence. Documented case: CityXerpa — 4 h → 8 s.
See the CityXerpa case →Go backend serving Flutter apps in production with millions of requests. Auth, rate limiting, microservice aggregation and aggressive caching in a single layer.
Go workers consuming from Pub/Sub or Kafka, with a bounded goroutine pool, dead-letter queue and backpressure. 10× throughput vs Node equivalents with no extra effort.
Pricing engines, payment routers and scoring services where p99 < 100 ms is contractual. Go delivers that SLA without constant tuning.
Connectors between ERPs, CRMs and external APIs. Go binaries deploy wherever needed — Cloud Run, GKE, on-prem — without changing code.
Batch processors and streaming ingestion into BigQuery, Redshift or Snowflake. Native concurrency lets Go compete with Spark for many cases at a tenth of the cost.
Process
Bi-weekly sprints, live demos every other Friday, fixed price after Discovery. No invoice surprises.
01
Audit of the current problem (latency, cost, technical debt), review of the existing stack and definition of the target SLO. We decide together whether Go fits or whether the right answer is something else.
1 wk
02
Service architecture in Go: routing, contracts, persistence, messaging, observability. Working prototype deployed on Cloud Run with real load tests.
2–3 wks
03
Production-ready service: handlers, middleware, error handling, structured logging, table-driven and integration tests with testcontainers, CI/CD to Cloud Run.
4–8 wks
04
Progressive rollout (canary), runbooks, Grafana / Cloud Monitoring dashboards, operational documentation. Handover session to the customer's team or we continue as 24/7 support.
1–2 wks
Related technical case
Support tickets from 4 h to 8 s. A Go service on Cloud Run orchestrating function calling over BigQuery. Stack breakdown, metrics and a 10-step improvements roadmap documented.
Technical FAQ
Each has its place. For services on the customer's hot path with a real SLA and aggressive autoscaling, Go wins on latency, footprint, concurrency and ops simplicity. Node is reasonable when the team is JavaScript end-to-end and the load is moderate. Python for ML/data science and prototyping. Java for environments with a deeply rooted enterprise ecosystem. We do not sell Go to teams it does not fit.
Cloud Run is the right answer for ~80% of stateless HTTP/gRPC services: transparent 0→N autoscaling, no node management, no pod crashloops, minute-scale deploys. GKE comes in when you need sidecars, complex cron jobs, stateful workloads or fine-grained network control. For simple services, GKE adds operational complexity without benefit.
Standard stack: official OpenTelemetry SDK for tracing and metrics, exported to Cloud Trace or Datadog as the customer prefers. Structured logging with slog (Go 1.21+) writing JSON to stdout, indexed by Cloud Logging. Prometheus-compatible metrics on /metrics. Always-on pprof behind auth for reactive profiling. Grafana or Cloud Monitoring dashboards with SLIs/SLOs per endpoint.
By default, lightweight hexagonal: HTTP/gRPC handlers, application layer with use cases, pure testable domain and adapters towards infra (DB, queues, external APIs). No orthodox DDD unless the domain warrants it — over-engineering is the enemy. Table-driven tests in the domain, testcontainers integration in adapters. Linting with golangci-lint in CI, race detector active in tests.
Both. Typical migrations: PHP/Ruby/Python monoliths with latency bottlenecks chunked into Go microservices by domain. Migration usually follows the strangler pattern — the new Go service progressively absorbs traffic via a proxy, no big bang. We keep API compatibility while the change runs.
Five gates: (1) golangci-lint with strict config in CI; (2) tests with negotiable minimum coverage (60–80% depending on criticality); (3) race detector in CI; (4) mandatory peer review by a senior before merge; (5) integration tests with testcontainers against real dependencies (Postgres, Redis), not mocks. No exceptions.
A well-scoped Go microservice on Cloud Run with persistence, observability and CI/CD starts at €25,000–40,000 in development. Larger migrations (Python or Node to Go with the strangler pattern) sit at €60,000–150,000 depending on scope. Monthly support from €3,500/month with negotiable SLA. Fixed price after Discovery.
Yes, when the case calls for it: stateful workloads (databases, queue brokers), complex cron jobs, sidecars (Istio, OPA) or advanced network requirements. For greenfield we start on Cloud Run and migrate to GKE only when the real need appears. Provisioning with Terraform, deployments with Helm, observability with Prometheus + Grafana.
Got a backend bottleneck?
Latency, cost, technical debt, observability. We deliver an executive report with priorities and a Go migration plan (or whatever makes sense) — even if the plan does not hire us.
100% senior in-house team in Barcelona and Andorra · Reply within 24 h