All services

Freelance Go / Golang Developer

A freelance Go developer for the paths where latency costs money.

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.

3M+ requests a day<10ms latencygRPC & HTTPMulti-region on AWS
What I get hired for
  • New services in Go, from the interface contract to production
  • Extracting high-load paths out of PHP, Java or Node systems
  • gRPC and HTTP APIs with clean, versioned contracts
  • Distributed systems that plan for failure instead of experiencing it
  • Go on AWS: ECS, Lambda, DynamoDB, described in Terraform
  • Measuring and fixing an existing service that is too slow
Scope & working together

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

Go solves a load problem. First it has to be clear you have one.

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 into
  • An endpoint or job no longer holds the load, and scaling gets more expensive instead of better.
  • A rewrite in Go was recommended, and you would like a second opinion with a measurement.
  • A new service has to cope with millions of requests a day from day one.
  • Your team knows PHP, Java or Node, but nobody has run Go in production.
  • An existing Go service has been left behind without its author.
  • Two systems need to talk over a clean, versioned interface.

Who this is for

For teams where one path has to do more than the rest.

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.

01

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.

02

The existing system should stay.

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.

03

Operations are part of the requirement.

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

What I work on in Go

01

Measure first, decide second

ProfilingpprofLoad measurement

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.

02

New services in Go

Standard libraryContext & timeoutsGraceful shutdown

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.

03

gRPC and HTTP APIs

gRPCProtobufOpenAPI

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.

04

Distributed systems and resilience

IdempotencyCircuit breakerMulti-region

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.

05

Go on AWS

ECS & LambdaDynamoDBTerraform

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.

06

Go alongside PHP and other existing systems

Strangler figgRPC integrationClear data boundary

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

Go services alongside PHPThe most common entry point: one path is measured and put alongside your PHP as a Go service. Its own page with the approach and a bottleneck measurement at a fixed price of 1,900 euros.
Backend developmentWhen it is not about a single path but a backend for a SaaS or platform: event-driven on AWS, multi-tenant, with load resilience in the design. Its own service page.

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

How an engagement starts

Four steps, with a measurement instead of an opinion at the start. No step commits you to the next.

STEP 01

First call, 30 minutes

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.

STEP 02

Measurement with findings

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.

STEP 03

One service, in production

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.

STEP 04

Extend and hand over

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

What is different afterwards

The path carries the load

The number is in the final report, not in a brochure: measured before and after, on the same paths, under real load.

The existing system stayed untouched

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.

Failure is planned for

Timeouts, retries and load limits are designed rather than grown. What can go wrong has a defined path instead of producing an incident.

Your team can do Go

The service is handed over, not just delivered: pairing during the build, runbooks for operations, decisions documented instead of remembered.

Technologies I use

What I work with

Language
  • Go
  • Generics
  • pprof
  • Race detector
Interfaces
  • gRPC
  • Protobuf
  • REST / OpenAPI
  • Webhooks
Data
  • DynamoDB
  • PostgreSQL
  • MySQL
  • Valkey / Redis
Messaging
  • SQS
  • SNS
  • EventBridge
  • Kafka
Runtime
  • ECS Fargate
  • Kubernetes
  • Lambda
  • Docker
Infrastructure
  • AWS
  • Terraform
  • Multi-region
  • CloudFront
Observability
  • CloudWatch
  • Prometheus
  • Grafana
  • Structured logs
Method
  • Spec-driven development
  • Claude Code
  • Small commits
  • Trunk-based

From practice

Also from real projects

Tim Rutte, Cloud & Software Architect

Who you are talking to

Directly with me as a freelancer. No agency in between.

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.

  • 20+years in software development
  • 50+successful projects
  • 2003working remotely since then
More about me

Working together

Working with your team or delivering independently.

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.

01Together

I work as part of your team.

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.

  • Integration into your sprints, reviews and technical decisions
  • Pairing and knowledge transfer throughout delivery
  • Code, documentation and operations remain fully with your team
02Independent

I take ownership of delivery.

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.

  • One point of contact from clarification through to delivery
  • Regular, clear progress updates without day-to-day supervision
  • A proper handover with documentation and a walkthrough

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

Your system remains yours.

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.

01

Access stays with you.

Code, cloud accounts, pipelines and secrets live in your systems. Operations never depend on a personal account or credentials that only I control.

02

Knowledge does not stay in my head.

Architecture decisions, operating procedures and known risks are documented where your team will find them and kept current as the work progresses.

03

Someone else can take over.

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

Common questions for a freelance Go developer

What does a freelance Go developer cost?

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.

Go or Golang, is that the same thing?

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.

Should we rewrite our whole system in Go?

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.

Our backend is PHP. Does Go fit alongside it?

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.

How do we know beforehand that Go will solve the problem?

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.

Do you also take over an existing Go service?

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.

Microservices or monolith?

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.

You work with AI tooling. Who reviews its code?

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

What else I help with.