The load is real, not projected.
There are numbers: requests per second, runtimes, timeouts, cost per scaling step. Or there is a service that will have to deliver them soon, with a deadline.
Freelance Go / Golang Developer
If a single path no longer carries your load, you do not need a rewrite or a framework creed. I build Go services for exactly those places: measured before decided, and in production alongside your existing system instead of in its place. The largest of them answers more than three million requests a day in under ten milliseconds, across two regions.
As part of your team or delivering independently, at a fixed price or by time spent to suit the project.
Remote from Germany. Straight with me, no agency in between.
The starting point
Most Go enquiries do not start with Go, they start with a symptom: an endpoint slows down under load, a batch run eats the night, a service needs a maintenance window for every deployment. Somewhere the existing platform has hit a limit, and Go is on the table because it was built for exactly these limits: predictable runtimes, low memory footprint, concurrency without contortions.
My work therefore does not start with code, it starts with a measurement. If the bottleneck sits in the database, a faster language changes nothing, and I will tell you so before you commission anything. Only when it is established that the path itself is the problem does a new build pay off, and then as a separate service alongside the existing system: connected via gRPC or HTTP, with a clear data boundary and its own way back. The rest of your system stays where it is.
That this works is proven, not claimed: for a global AdTech platform I replaced a manual process spread across departments with a Go service that answers more than three million requests a day in under ten milliseconds, multi-tenant and in two regions. For a payment backend with more than six million users I built new Go microservices alongside the existing system without interrupting payment operations: 15% fewer payment drop-offs, 75% shorter deployments.
And the honest limit belongs here too: Go is not a replacement for your entire system and not a mark of quality in itself. A rewrite of the whole application in Go is almost always the wrong recommendation, even though it is often given. The value appears where a well-bounded path has high demands on latency, throughput or parallelism. There, however, reliably.
Situations I get called intoWho this is for
This page is for CTOs, engineering leads and platform owners with a running system in which individual places have significantly higher demands on latency, throughput or availability than the rest.
There are numbers: requests per second, runtimes, timeouts, cost per scaling step. Or there is a service that will have to deliver them soon, with a deadline.
What you have works for what it was built for. You are not looking for a replacement, but for a service alongside it that takes over the critical part.
The service should not just be fast, but observable, deployable and ready for handover. Your team should be able to develop it further without me.
What I do
Before the first line of Go there is a bottleneck measurement: where exactly the time is lost, what the path costs today, what a different runtime would actually change. If the problem sits in the database or the data model, that is the finding, and it is cheaper than a service that changes nothing.
From the interface contract to production: small, clearly cut services with explicit failure paths, timeouts and backpressure. No framework zoo, but the standard library plus the little that has proven itself in production.
Contracts first: Protobuf or OpenAPI, versioned, with backwards compatibility as the rule rather than a stroke of luck. PHP, Java or Node systems can then connect to the new service without every change breaking both sides.
Failure is in the design, not in the postmortem: idempotent retries, circuit breakers, rate limiting, layered caches. The attribution service from my case studies runs this way in two regions, and a region outage is an event, not an incident.
The runtime is half the work: ECS or Kubernetes, Lambda where it fits, DynamoDB and Valkey for the paths that have to be fast, all described in Terraform. As an AWS Certified Solutions Architect – Professional I design the environment along with the service instead of adjusting it afterwards.
The most common route to Go leads through a grown system: one path is extracted, the rest stays. I know both sides of that boundary from my own work, more than 20 years of it in PHP, and I have described the approach in a dedicated article.
Specific cases
Tell me which path no longer carries the load.
30 minutes, directly with me. If Go is the wrong answer to your problem, I will tell you so in the same call, along with the better one.
How it runs
Four steps, with a measurement instead of an opinion at the start. No step commits you to the next.
You describe symptom and system: which path, what load, what runs there today. I tell you whether Go is plausible and how I would verify it.
The bottleneck is measured, not estimated. The outcome is a written report: where the time is lost, what a Go service would change and what it would not.
The first service goes live as a well-bounded piece, connected via gRPC or HTTP, with metrics and a way back. Small enough to review, real enough to measure.
What proves itself gets extended. Your team takes over with pairing, runbooks and a service that can be operated and developed without me.
The outcome
The number is in the final report, not in a brochure: measured before and after, on the same paths, under real load.
No rewrite, no cut-over date. What you had kept running, the new service came alongside, and the boundary between the two is a documented interface.
Timeouts, retries and load limits are designed rather than grown. What can go wrong has a defined path instead of producing an incident.
The service is handed over, not just delivered: pairing during the build, runbooks for operations, decisions documented instead of remembered.
Technologies I use
From practice
Greenfield development of a multi-tenant gRPC service in Go for a global AdTech platform. A manual process spread across departments replaced by highly available infrastructure in the EU and US, with a layered cache architecture.
Read the case studyAlso from real projects
The five places where Go means something different from what it looks like: errors as return values carrying context, bounded concurrency with cancellation, packages as boundaries, interfaces at the consumer, and why the missing framework is deliberate.
Read the articleA payment API that no longer scaled: the existing system stabilized, new Go microservices built alongside it and connected via gRPC, without interrupting payment operations. 15% fewer payment drop-offs, 75% shorter deployments.
Read the case studyHow new, high-performance Go services come into existing PHP systems without rebuilding everything: strangler fig in practice instead of a big-bang rewrite, with the decisions that are genuinely hard along the way.
Read the article
Who you are talking to
I am Tim Rutte. More than 20 years in software development; I use Go where latency and throughput decide over money. You talk to the person who touches your code, from the first call to the handover.
Working together
You do not need to bring a particular setup. I adapt the engagement to how your company works and how much responsibility you want to hand over.
If knowledge and responsibilities already sit with you, I join wherever additional experience is needed. Inside your workflows, in direct contact, without creating a parallel track.
If you lack time or capacity internally, I take a clearly scoped piece of work from technical clarification through to production. You set the objective and constraints; I take care of the path there.
Whichever model you choose, you always know what is being built, which decisions are pending and what happens next. Billing follows the project and the model you prefer: clearly bounded work at a fixed price, longer or more open-ended work by time spent.
Continuity
Independent delivery does not create dependency on me. Everything required to develop and operate the result stays in your environment from day one and remains ready for handover throughout the engagement.
Code, cloud accounts, pipelines and secrets live in your systems. Operations never depend on a personal account or credentials that only I control.
Architecture decisions, operating procedures and known risks are documented where your team will find them and kept current as the work progresses.
Reproducible environments, automated deployments and regular handovers allow your team or another provider to continue without starting again.
The goal is not for you to depend on me permanently. The goal is for you to remain free to decide who develops the system next.
Common questions
At a fixed price or by time spent, to suit the project and the model you prefer; I name the range in the first call, once scope and timeframe are clear. For the most common entry point there is a package with a price: the bottleneck measurement of your application at a fixed price of 1,900 euros, with a result within a week. It is credited if you commission the implementation afterwards.
Yes. The language is called Go; "Golang" established itself as a search term because "Go" on its own is hard to search for. Both mean the same language, and this page answers both searches.
Almost certainly not, and I say that although I would earn money from it. A complete rewrite loses the unwritten rules of the existing system and chases a moving target for years. The reliable path is to extract the path with the load problem and put it alongside as a Go service. The rest stays until there is a reason of its own for the next step.
That is the normal case, not the exception. The Go service takes over the path that needs load or latency and is connected via gRPC or HTTP, with the same database or a clear data boundary. I have more than 20 years of PHP experience and know both sides of that connection; what it looks like in practice is in my article on Go in a PHP world.
By measuring instead of believing. Before the implementation there is a bottleneck measurement: where is the time actually lost, in the code, the database, the network? If the bottleneck does not sit in the path itself, a faster language changes nothing, and then you get exactly that finding instead of a service that improves nothing.
Yes. Go services get left behind without their author too, usually with little documentation and a deployment only one person knew. The process is the same as with any takeover: understand and secure first, change second. Tests, metrics and runbooks are created along the way, so the dependency on one person does not merely change its name.
That is not a question of faith but of cut. A single, clearly bounded Go service alongside an existing system is often the whole answer; a web of twenty micro-services almost never is. I cut along data boundaries and rate of change, not along architecture fashions, and I justify the cut in writing.
I do, and systematically. I work spec-driven: requirements are written down precisely before code is produced, and every change passes tests, the race detector and review before it reaches your repository. The tools bring speed; the quality gates are the same as for handwritten code. I am responsible for the result, not the tool.
Other services
Backends for SaaS and platforms that hold under real load: Go and PHP 8, event-driven, with tenant isolation and recovery designed in.
Learn moreModernizing grown systems step by step: strangler fig instead of a rewrite, operations untouched, every step reversible.
Learn moreFrom your own data centre or another cloud onto AWS, with a cost model before the move and a rollback path for every step.
Learn more