Engineering Journal 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 a High-Throughput TCP Server in Go

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

When building a high-throughput backend service, it is easy to focus on the application protocol and overlook the network boundary underneath it.

Strata-Log takes the opposite approach.

The project uses raw TCP connections as its ingestion layer, making connection handling, timeouts, concurrency, and shutdown behavior explicit.

That creates a useful engineering environment for understanding what actually happens between a client sending data and a backend processing it.

Why Raw TCP?

Higher-level protocols and frameworks are valuable because they provide useful abstractions.

Building Asteroids with Python and Pygame: From Game Idea to Playable System

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

Building Asteroids with Python and Pygame: From Game Idea to Playable System

Small games are deceptively useful engineering projects.

They may contain only a few objects on screen, but those objects introduce many of the same problems found in larger software systems: state management, object lifecycles, input handling, timing, rendering, collision detection, and the need to keep individual components understandable as the codebase grows.

The Asteroids project was built as an opportunity to explore those problems through a compact interactive system using Python and Pygame.

Building Platform-Infra: Using Terraform to Manage Local Kubernetes Infrastructure

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

Building Platform-Infra: Using Terraform to Manage Local Kubernetes Infrastructure

Infrastructure becomes difficult to reason about when environments are created through a collection of undocumented commands.

That problem becomes even more noticeable when several services, containers, configuration files, namespaces, and deployment steps are involved.

Platform-Infra started from that observation.

The project is a master orchestration repository designed to manage the infrastructure and deployment configuration surrounding my backend services using Infrastructure as Code principles.

From Markdown to HTML: Designing the Static Site Generator Pipeline

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

From Markdown to HTML: Designing the Static Site Generator Pipeline

A static site generator is fundamentally a transformation system.

It takes source content, processes that content through a series of stages, and produces files that can be served directly to users.

For my static site generator, the core transformation looks like this:

Markdown
 ↓
Blocks
 ↓
Block Types
 ↓
Inline Text Nodes
 ↓
HTML Nodes
 ↓
HTML

The value of this architecture is not simply that it works.

Building a Static Site Generator in Python: From Markdown to HTML

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

Building a Static Site Generator in Python: From Markdown to HTML

A static site generator looks simple from the outside.

You write some Markdown, run a command, and HTML files appear in an output directory.

The interesting engineering work happens between those two points.

Building a static site generator from scratch is a useful exercise because it exposes several concepts that are normally hidden behind frameworks and libraries: parsing, intermediate representations, tree structures, rendering, filesystem operations, and deterministic builds.

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:

Converting Markdown Blocks into Semantic HTML

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

Converting Markdown Blocks into Semantic HTML

Markdown documents are written as a continuous stream of text, but browsers consume structured HTML.

Bridging those two representations requires more than replacing a few characters.

A static site generator needs to understand the boundaries between blocks and determine what each block represents.

That was one of the central problems in my Static Site Generator project.

What Is a Markdown Block?

A block is a logical unit of Markdown content.

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 OpsPilot: Building a Modular DevOps Operations Toolkit

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

Designing OpsPilot: Building a Modular DevOps Operations Toolkit

As backend systems become more complex, the operational work surrounding them becomes increasingly difficult to ignore.

Running services, inspecting environments, managing containers, checking infrastructure, and performing repetitive maintenance tasks can quickly turn into a collection of shell commands, scripts, and undocumented procedures.

That was the problem I wanted to explore with OpsPilot.

Rather than building another collection of unrelated scripts, I wanted to create a structured operations toolkit that could grow alongside the systems it manages.

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.

Parsing Markdown into an HTML Tree: Designing the Intermediate Representation

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

Parsing Markdown into an HTML Tree: Designing the Intermediate Representation

One of the easiest mistakes to make when building a Markdown-to-HTML converter is to think of the problem as string replacement.

Replace **text** with <strong>text</strong>.

Replace *text* with <em>text</em>.

Replace headings with <h1>.

At first, this seems sufficient.

It quickly becomes difficult once documents contain nested structures.

A more robust approach is to introduce an intermediate representation between Markdown and HTML.

Testing a Static Site Generator: Small Contracts, Reliable Output

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

Testing a Static Site Generator: Small Contracts, Reliable Output

A static site generator is a good example of a system where small bugs can propagate through multiple layers.

A mistake in Markdown parsing can eventually appear as malformed HTML.

A malformed text node can produce incorrect links.

A block-classification error can cause an entire section of a page to render incorrectly.

That makes testing especially important.

The solution is not necessarily hundreds of large end-to-end tests.

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 a Reliable REST API Client in Go for PokedexCLI

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

Building a Reliable REST API Client in Go for PokedexCLI

A command-line application becomes considerably more interesting when it has to communicate with a remote service.

PokedexCLI does not contain all of its data locally. Much of the information the application needs comes from the Pokémon API, which means the application has to deal with HTTP requests, JSON responses, network failures, pagination, and external service boundaries.

Rather than allowing every command to construct its own HTTP requests, I treated API communication as a dedicated responsibility.

Building Reliable Tool Use into an AI Agent

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

Building Reliable Tool Use into an AI Agent

The moment an AI agent needs to interact with something outside the language model, tool use becomes central to its design.

A model can explain how to query a database.

It cannot query the database unless the surrounding application gives it a mechanism to do so.

That mechanism is the tool.

Why Tools Matter

A language model operates primarily through generated information.

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.

Caching API Responses in PokedexCLI: Reducing Network Work in Go

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

Caching API Responses in PokedexCLI: Reducing Network Work in Go

One of the easiest performance problems to overlook in an API-driven application is repeated work.

If an application repeatedly requests the same resource from a remote service, every request introduces network latency and another dependency on the availability of that service.

PokedexCLI provides a useful environment for exploring this problem because the application repeatedly interacts with the Pokémon API while the user navigates locations and explores areas.

Designing a CLI Architecture for PokedexCLI in Go

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

Designing a CLI Architecture for PokedexCLI in Go

Building a command-line application can look deceptively simple.

At first, the requirements for PokedexCLI seem straightforward: accept a command, execute it, call the Pokémon API when necessary, and print the result.

But even a small CLI becomes difficult to maintain when command handling, application state, networking, caching, and presentation logic are allowed to grow together.

For PokedexCLI, I wanted to approach the problem as a real software-engineering exercise rather than simply building a collection of commands that happened to work.

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:

Designing the Architecture of an AI Agent

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

Designing the Architecture of an AI Agent

Building an AI agent is very different from building a simple application that sends a prompt to a language model and displays the response.

A useful agent needs to do more than generate text. It needs to interpret a goal, decide what should happen next, use tools when necessary, maintain enough state to complete the task, observe the result, and recover when something goes wrong.

Making an AI Agent Reliable

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

Making an AI Agent Reliable

The most impressive AI agent demo can still be a poor piece of software.

A demonstration may work perfectly when the model responds as expected, every API is available, every tool succeeds, and the task is small.

Real systems are not that forgiving.

Models produce unexpected outputs.

Networks fail.

Tools time out.

External APIs change.

Users provide ambiguous instructions.

An agent that cannot handle these conditions is not reliable.

Managing Memory and State in an AI Agent

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

Managing Memory and State in an AI Agent

An AI agent becomes significantly more useful when it can maintain context across multiple steps.

But “memory” is often used too loosely.

For an engineer, it is more useful to distinguish between the different kinds of information an agent needs to retain.

Some information belongs to the current execution.

Some belongs to the conversation.

Some may need to persist beyond the current session.

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.

What Building PokedexCLI Taught Me About Backend Engineering in Go

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

What Building PokedexCLI Taught Me About Backend Engineering in Go

PokedexCLI began as a relatively small Go application.

The premise is simple: interact with Pokémon data through a command-line interface.

But projects do not remain simple merely because their initial requirements are simple.

As functionality grows, the application has to deal with API communication, pagination, application state, caching, command dispatch, data modeling, errors, and testing.

That made PokedexCLI valuable as more than a CLI exercise.

Designing This Portfolio as an Engineering Project

Wed, 05 Aug 2026 00:00:00 +0000

A technical portfolio should do more than list technologies.

For an engineer working in backend systems, distributed systems, and platform engineering, the portfolio itself is an opportunity to demonstrate how problems are approached, how systems are designed, and how engineering decisions are communicated.

That became the foundation for this project.

More Than a Portfolio

The intention behind this site is to present engineering work in a way that reflects the work itself.

Building OpsPilot: Why I Started a DevOps Platform

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

OpsPilot started with a simple question: what would happen if I built the operational tooling I kept wishing I had?

As I continued working across backend engineering, DevOps, and cloud-native infrastructure, I found myself repeatedly dealing with the same categories of operational work. Instead of treating those tasks as isolated scripts and commands, I wanted to explore what it would look like to bring them together into a coherent engineering platform.