Systems-Thinking on Lorbic

Cache-Driven Development: Saving Your Database From Itself

Wed, 22 Jul 2026 12:00:00 +0530

There is a moment in every backend engineer’s life when their database starts refusing connections.

Picture 2 a.m. on a Tuesday. The app is operating under normal traffic, nothing unusual. But the database connection pool is saturated. Queries are timing out. The monitoring dashboard shows 50,000 database operations per second, far beyond what the system should be handling.

When someone pulls the slow-query logs, the pattern is immediately clear. The same query appears thousands of times:

So, We Are Writing Efficient Software Again

Wed, 17 Jun 2026 20:00:00 +0530

I wanted to upgrade the RAM in my PC.

Nothing fancy. I bought 32GB in 2024 and I wanted to double it. I opened a tab, checked the price, and closed the tab. Then I sat quietly for a moment.

The same 32GB kit I bought in 2024 now costs more than double. DDR5 prices have gone up roughly 400% since mid-2025 [1]. DDR4 is not much better. A kit that cost $60–$90 in late 2025 now sells for $150–$180 [2].

Constructing Concurrent Inverted Indexes in Go

Tue, 16 Jun 2026 22:00:00 +0530

I spent a Saturday afternoon benchmarking a concurrent inverted index and discovered that a single sync.RWMutex starts to break down at roughly 4 concurrent readers. The degradation is not linear. It is not graceful. It is a cliff.

The inverted index is one of the oldest data structures in information retrieval. It maps terms to the documents that contain them, forming the backbone of every search engine from Elasticsearch to Lucene to Google’s earliest prototypes. The data structure itself is simple. Making it fast under concurrent load is not.

A Love Letter to the L1 Cache

Mon, 15 Jun 2026 19:00:00 +0530

I recently spent four hours staring at a benchmark that didn’t make sense.

It started while working on Derelict Facility, my grid-based game engine in Go. I was trying to tighten the main update loop, specifically the part that iterates over every entity on the map each frame. I pulled out a small benchmark to isolate the cost, and something looked wrong.

I had two Go structs. They held the exact same data: two booleans and a 64-bit integer. I was iterating over a slice of 10 million of these structs, doing a simple addition. They should have been identical in performance.

Why Explaining Technical Difficulty is Hard

Thu, 14 May 2026 01:00:00 +0530

“Can we just add a real-time visitor counter to the homepage? It’s just a query, right”?

Every engineer has heard some variation of this. On the surface, the logic is sound. You have data, you have a UI, and you want to connect them. In the world of business requirements, this is a solved problem. You write a line of code, and the feature exists.

But your database doesn’t care about business logic. It cares about Infrastructure Constraints.

AI Coding in 2026: Productivity Multipliers vs. Skill Replacements

Sat, 28 Mar 2026 23:00:00 +0530

“Write a REST API with authentication”.

I hit enter. Thirty seconds later, Claude spat out 400 lines of perfectly formatted Go code. JWT middleware, password hashing, error handling, even rate limiting. It looked professional. It looked production-ready.

It took me three hours to figure out why the token refresh logic had a race condition.

This is AI-assisted coding in 2026. It’s not magic. It’s not a replacement. It’s a very fast junior developer that never gets tired, never complains, and confidently makes mistakes you won’t catch unless you actually understand the architectural nuances of what you’re building.

What Couchbase Taught Me About System Thinking

Tue, 18 Nov 2025 02:20:06 +0530

Couchbase Internals: Indexes, Queries, Consistency, and Performance

Introduction

Over the last few years I’ve lived deep inside backend systems, and for the past year and a half Couchbase has been my daily companion. Working with Go services that depend on Couchbase taught me that the real lessons aren’t in the marketing slides or quick‑start guides. They’re in the internals: how indexes are built, how queries are planned, how consistency flags change the story, and how durability levels quietly decide whether your system survives a failure or not.

What Facebook's Memcache Taught Me About Systems Thinking

Mon, 07 Jul 2025 14:03:00 +0000

What Facebook’s Memcache Taught Me About Systems Thinking

“The probability of reading transient stale data is a tunable parameter”. - Scaling Memcache at Facebook (NSDI, 2013)

There’s a moment in every engineer’s life when a seemingly simple component like a cache, suddenly becomes the most complex piece in the stack. For me, that moment arrived reading Facebook’s paper on scaling Memcache. I didn’t expect a key-value store to challenge my understanding of systems architecture. But this paper wasn’t about cache keys or TTLs. It was about what happens when infrastructure hits the limits of scale, physics, and human reliability.
What follows isn’t a summary. It’s a set of systems insights that stayed with me, principles that go deeper than code and that I now see everywhere.