We returned to GopherCon UK

Mid-August marks a new tradition for us at Nimble Ape: GopherCon UK. Held at The Brewery in central London, it’s a two-day, three-track conference all about Go, including everything from side projects to industry success stories, from memory optimization strategies to the inner workings of the standard library.

After last year’s experience, we came to expect very high-quality talks, an amazing venue, and great food... and GopherCon delivered!

Here are a few talks that stood out:

Climbing the Testing Pyramid, by Naveen Ramanathan

While testing against real cloud environments gives you the best level of confidence, this is not always possible, for example due to limited access permissions. And even when you have full access, testing for failures is not trivial.

This talk broke down different approaches to testing cloud integrations in Go: from hitting real services like AWS S3, to using tools like toxiproxy for simulating failures, to emulators like LocalStack, to rolling your own mocks with the httptest package.

The key takeaway: Identify the right level of abstraction for your needs. Sometimes mocks via interfaces are the cleanest path, but they come with maintenance trade-offs.

Opening High-Traffic Access Points Using Go, by George Kampanos

I really enjoyed this talk about how George helped modernize his friend’s gym by controlling a turnstile access door, and building the infrastructure around it, all in Go, and all within a very tight budget. George showed how Go powers scalable database access with Goose and how platforms like fly.io make small-scale deployments economical.

A great reminder of how Go’s ecosystem keeps lowering the barrier to building fast, reliable services, without compromising on scalability.

K8s CPU Limits Deconstructed, by Bill Kennedy

The talk explained how CPU quotas in Kubernetes interact with Go’s scheduler and why mismatches between the number of cores the scheduler thinks it can use, and what Kubernetes actually provides, can cause excessive context switching and loss in performance.

Go’s scheduler shines at turning I/O-bound workloads into efficient CPU usage, but you need to be aware of how K8s throttles cores. Leveraging both concurrency (splitting the workload in chunks that can be executed out of order) and parallelism (carrying out work at the same time on different processors) is key in maximising your program’s performance. Tools like Uber’s automaxprocs and changes in Go 1.25 help, but it’s still an area that requires careful planning and tuning.

Final Thoughts

Go continues to prove why it’s often our language of choice when we start a new project. Whether it’s testing, scaling, or running in Kubernetes, the talks reinforced what we see daily in our own work: Go makes it easier to tackle projects of any size, while providing excellent performance and reliability.

For us at Nimble Ape, GopherCon wasn’t just another conference: It was a chance to sharpen our skills, connect with the community, and keep pushing the boundaries of what we can build with Go.

Need help?

Nimble Ape has been consulting on real-time media projects for over a decade. We build products, including in Go, for clients big and small all over the globe. If you’re working on these technologies and need some extra support, we’re happy to help.

Why not drop us a line on [email protected].