The service leaks memory and goroutines
Goroutines started on each request that never exit, usually blocked on a channel receive or an outbound call with no timeout.
Leaks found and closed
Working with Go?
A lot of Go services we take on were written start to finish by one engineer who has since moved on, with no tests and a go.mod file that has not been touched in three years. We read the code, add the tests that should have been there, and bring the dependencies forward without breaking the deploy.
What it is
Go, sometimes called Golang, is a statically typed, compiled language that came out of Google. It was designed by Rob Pike, Robert Griesemer and Ken Thompson, first released in 2009, and reached version 1.0 in 2012.
It has a compact specification, a famously fast compiler, a garbage collector, and goroutines with channels for concurrency. Dependencies are handled by the module system, which arrived in 1.11 and became the default in 1.16.
Much of the cloud infrastructure in common use today is written in Go. Docker, Kubernetes, Terraform, Prometheus, Hugo, CockroachDB, InfluxDB, etcd and Caddy are all Go programs, and so are a large share of the CLI tools and HTTP services that run behind modern products.
The honest version
No technology is all upside. This is where Go earns its place and where it tends to cause trouble.
Sound familiar?
The Go problems that bring people to us, and what you have once each one is fixed.
Goroutines started on each request that never exit, usually blocked on a channel receive or an outbound call with no timeout.
Leaks found and closed
A single engineer built it, left, and now every change is a leap of faith. We read the code, add tests for the real behaviour, and get a CI run that means something.
A test suite you can trust
A codebase stuck on GOPATH, dep or glide that will not build on a modern toolchain, and nobody has wanted to be the one to move it.
Modules, cleanly migrated
Code that targets 1.17 or earlier, pinned by a Dockerfile nobody has updated, blocking the use of generics and modern standard library helpers.
Upgraded version, green build
Shared state written from multiple goroutines without a mutex or channel to coordinate them, which looks fine in testing and panics in production.
Races fixed, detector clean
Downstream calls with no deadline set, or a context that never gets passed through, so slow dependencies stall the whole service.
Timeouts set, tails trimmed
Dependencies that drift, a go.sum that has been hand-edited, or a vendored tree that no longer matches go.mod.
Reproducible builds, pinned
The only person who knew the code is gone, with no documentation and no handover. We pick it up and keep it running.
Ownership back in your team
What we do
Call us for one leak, or hand us the whole service.
How it works
Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.
We fix the cause, not the symptom. If something is down, getting it back up comes first.
Backups, monitoring, updates and access, so the same problem can't quietly come back.
You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.
Often found together
We work on the whole stack, so the problem can be wherever it actually is.
Yes, and it is one of the most common jobs we do with Go. We read the code, write down what it actually does, add tests for the behaviour your business depends on, and leave you with something your current team can keep working on.
Yes. We migrate the project to a go.mod file, pin dependencies at known-good versions, remove vendored trees that are no longer needed, and verify the build on a current Go toolchain before any of it reaches production.
Almost always it is goroutines that never exit, usually blocked on a channel or an outbound call with no timeout set. We capture a goroutine profile from the running service, find what is stuck, and fix the code paths that start the leak.
We start with the paths that matter most to the business, add table-driven tests around them using the standard testing package, bring in the race detector on CI, and build out from there rather than trying to cover everything at once.
Yes. We run the upgrade against a copy first, fix anything the newer compiler is stricter about, update the Docker image and CI config together, and only then cut over the real deploy.
Estimates are free. Tell us what the service does and what is going wrong, and you get a price before any work starts.
Free estimate
Tell us what you're running and what's going wrong. A person reads it and comes back with an estimate.
Your message is with a real person, and we'll get back to you soon.
Rather talk now? Call us: