Distributed Systems on Ikwuka Okoye

Building a Concurrent TCP Server in Go: Connections, Deadlines, and Graceful Shutdown

Tue, 11 Aug 2026 00:00:00 +0000

Building a Concurrent TCP Server in Go: Connections, Deadlines, and Graceful Shutdown

TCP makes it possible to build extremely simple network services.

Open a listener. Accept a connection. Read bytes. Process them.

The complexity appears when the server has to do this for many clients at the same time while remaining responsive when clients become slow, disappear unexpectedly, or send data indefinitely.

That was one of the core engineering problems behind Strata-Log.

Building Distributed Rate Limiting with Redis and Lua

Mon, 10 Aug 2026 00:00:00 +0000

Building Distributed Rate Limiting with Redis and Lua

Rate limiting sounds simple until an application runs on more than one machine.

A single process can keep a counter in memory.

A distributed gateway cannot rely on local state alone.

While building Flux-Gateway, I used Redis and Lua scripts to explore how traffic control can remain atomic when multiple gateway instances are operating simultaneously.

Why Local Rate Limiting Is Not Enough

Imagine two gateway instances:

Designing a Fault-Tolerant API Gateway in Go

Mon, 10 Aug 2026 00:00:00 +0000

Designing a Fault-Tolerant API Gateway in Go

An API gateway sits at an uncomfortable boundary.

It receives traffic from clients, but the work is usually performed somewhere else. Every request that passes through the gateway eventually depends on downstream services, networks, databases, caches, or other infrastructure.

That makes the gateway more than a reverse proxy.

It becomes one of the places where reliability decisions have to be made.

This is the problem I wanted to explore while building Flux-Gateway, a high-performance API gateway and reverse proxy written in Go.

Designing Strata-Log: Architecture for a High-Throughput Distributed Log Engine

Mon, 10 Aug 2026 00:00:00 +0000

Building a log aggregation system looks deceptively simple at first.

Accept a connection, read some data, and write it somewhere.

The difficulty begins when the system has to do that thousands of times concurrently without allowing network traffic, memory allocation, disk I/O, or shutdown behavior to become bottlenecks.

That problem became the foundation for Strata-Log, an experimental high-throughput distributed log aggregation engine built in Go.

The project is deliberately focused on the lower layers of the system: TCP connections, concurrency, memory reuse, buffering, disk writes, and graceful shutdown.

Building a Circuit Breaker in Go

Sun, 09 Aug 2026 00:00:00 +0000

Building a Circuit Breaker in Go

A backend service does not operate in isolation.

Even a relatively simple HTTP handler may depend on databases, caches, authentication services, payment providers, internal APIs, or other microservices.

When one of those dependencies becomes unhealthy, repeatedly calling it can make the original problem much worse.

This is where the circuit breaker pattern becomes useful.

While building Flux-Gateway, I implemented a circuit breaker in Go to explore how a gateway can detect repeated upstream failures and stop sending traffic to a dependency that is already known to be unhealthy.

Building Strata-Log: Designing a High-Throughput Distributed Log Aggregator in Go

Sun, 09 Aug 2026 00:00:00 +0000

Building Strata-Log: Designing a High-Throughput Distributed Log Aggregator in Go

Log aggregation looks simple until the volume increases.

At low traffic levels, accepting a connection, reading log lines, and writing them to disk is straightforward. The problem changes when thousands of clients begin producing data concurrently and the system has to keep accepting connections without allowing slow storage operations to become a bottleneck.

Strata-Log started from that problem.

The goal was to build a high-throughput log aggregation engine in Go that could safely process large numbers of concurrent log streams over raw TCP while keeping memory usage predictable and the architecture understandable.

Designing Fail-Fast Boundaries for Microservices

Sun, 09 Aug 2026 00:00:00 +0000

Designing Fail-Fast Boundaries for Microservices

One of the easiest mistakes to make in distributed systems is assuming that a failed request is simply a request that returned an error.

A timeout is more expensive.

The system may have spent seconds holding connections, goroutines, memory, and other resources before discovering that the dependency could not respond.

That is why fail-fast behavior is an important reliability mechanism.

Slow Failure Is Still Failure

Consider a request travelling through several services:

What Building an AI Agent Taught Me About Backend Engineering

Sun, 09 Aug 2026 00:00:00 +0000

What Building an AI Agent Taught Me About Backend Engineering

Building an AI agent initially appears to be an exercise in working with language models.

In practice, much of the work quickly becomes familiar backend engineering.

Requests need validation.

State needs to be managed.

External services need timeouts.

Failures need to be handled.

Operations need to be observable.

Components need clear boundaries.

The language model adds a new dimension, but many of the underlying engineering principles remain the same.