Deep Dive on Lorbic

Couchbase Index Best Practices and Query Performance Tuning

Fri, 31 Jul 2026 23:00:00 +0530

Most Couchbase performance tickets I have seen end the same way: someone adds more nodes, the dashboard looks a little better for a week, and the same query shows up in the slow log a month later. The node count was never the problem. The index was.

This is a working reference, not an essay. I already wrote the reflective version of what indexing in Couchbase teaches you about systems in general. This post skips the reflection and gets straight to the decisions: which index type to reach for, how to order composite keys, how to tell if a query is actually using what you built, and which four or five mistakes account for most of the slow queries you will ever debug. Couchbase’s own documentation is the primary source for the recommendations below. Every example runs against travel-sample, the sample bucket Couchbase ships with every install, so you can paste these into your own cluster and see the plan yourself.

Why Your Goroutines Need a Speed Limit: Bounded Concurrency in Go

Fri, 10 Apr 2026 10:00:00 +0530

TL;DR: Spawning go func() without a limiter is a recipe for system collapse. This guide details how to use Semaphores and Worker Pools to prioritize predictable stability over absolute speed, protecting downstream dependencies from the thundering herd.

It’s a rite of passage for every Go developer. You receive a list of 10,000 URLs to fetch or 50,000 rows to process. You wrap the workload in an unbounded go func() loop, achieving maximum throughput in milliseconds.

Kubernetes on WSL2 and the macOS tunnel

Wed, 01 Apr 2026 22:00:00 +0530

TL;DR: I run k3s on a Windows gaming PC via WSL2 to master Kubernetes networking without cloud costs. This guide details a secure access model using SSH and kubectl port-forward to bypass NAT boundaries and maintain technical sovereignty.

This guide omits Kubernetes feature tutorials. Instead, it details how to architect an environment where Kubernetes can exist without auxiliary hardware, idle cloud bills, or hidden networking realities.

I wanted to learn Kubernetes properly, which meant understanding how scheduling, access paths, and network boundaries behave under real constraints. The problem was simple: I lacked a reasonable execution environment.

ClickHouse data masking with regex

Tue, 31 Mar 2026 22:30:00 +0530

If you’re running a production observability stack, you’ve already leaked PII. An engineer forgot to redact an email in a log line, or a JWT token ended up in a stack trace.

In most databases, the only fix is to DELETE the data—killing your metrics along with the sensitive info. But ClickHouse has a more elegant approach: Data Masking Policies.

By defining a policy at the role level, you can use regex to swap sensitive patterns with [REDACTED] in real-time, before the query results even leave the server.

Understanding CPU Caches in Go

Tue, 31 Mar 2026 22:15:00 +0530

When you’re building Go services that handle millions of operations per second, the hardware beneath your abstractions starts to matter. Specifically, the CPU cache hierarchy, and whether your data fits in it.

The Hardware Context: It’s Not Just “RAM”

Your server has 32GB or 64GB of RAM, but the CPU avoids touching it whenever possible. Instead, it works through a chain of caches:

ClickHouse vs. Postgres: When to Move Your Logs Out of a Relational DB

Mon, 30 Mar 2026 22:45:00 +0530

Postgres is the most reliable tool in my stack. It handles users, configurations, and complex relations without breaking a sweat. But databases, like any physical system, have a “design limit”. For Postgres, that limit usually appears when you try to use it as a dumping ground for high-velocity logs and metrics.

When your ANALYZE commands start taking minutes and your indexes consume more RAM than your data, you aren’t facing a Postgres bug; you’re facing an architectural mismatch.

WSL2 Is Slow? Fix /mnt/c/ File System Performance & Go Latency

Sun, 29 Mar 2026 22:30:00 +0530

WSL2 (Windows Subsystem for Linux) has been a godsend for developers who love Linux tools but need/have a Windows environment. But for Go developers, WSL2 isn’t just a “transparent layer”. If configured incorrectly, it becomes the bottleneck that can slow down builds by 3x and introduce mysterious latency in networked services.

This isn’t a failure of WSL2; it’s a failure of understanding the 9p boundary.

Glossary // What is the 9P Boundary?

WSL2 is a Virtual Machine. To let that VM see your Windows files, Microsoft uses the 9P protocol (Plan 9).

Go Struct Field Alignment: How Memory Padding Wastes Your RAM

Sat, 24 Jan 2026 10:00:00 +0530

You write a struct to represent a database entity. Maybe 10 fields, maybe 20. What could possibly go wrong?

Nothing, according to your tests. But somewhere in production, your heap is 30% larger than it should be, your Garbage Collector is working overtime, and your L1 cache is not used properly. The reason? Invisible padding bytes silently inflating every instance of your struct.

This is the story of struct field alignment: a memory optimization that costs nothing to implement but can significantly improve performance.

Memory Mechanics In Go - Stack vs Heap

Mon, 12 Jan 2026 00:10:00 +0530

We often talk about “fast” code in terms of Big O notation or algorithmic complexity. But in systems programming languages like Go, “fast” is often a function of where your data lives in memory.

When optimizing for high throughput, efficient loops and database indexes are only part of the story. Eventually, you have to talk about the Stack and the Heap.

Understanding the difference isn’t just trivia. It is the difference between a service that hums along at 100k OPS with flat latency, and one that chokes on Garbage Collection (GC) pauses every few seconds.

OLTP vs OLAP - Why You Need Two Databases

Sun, 11 Jan 2026 21:00:00 +0530

At a recent ClickHouse conference in New Delhi, I attended this Saturday. There were many interesting sessions, but one that stood out was a talk on multi-tenant analytics at scale. I was reminded of a fundamental truth in backend engineering: “The database that runs your app cannot be the database that analyzes your app”.

Early in a startup’s life, we shove everything into one database. User profiles, session data, logs, and analytics events all live in the same Postgres, Mongo, or Couchbase instance. It works, until it throttles.

Go Garbage Collector Mechanics: Pacer, GOGC, and Allocation Latency

Wed, 07 Jan 2026 00:21:12 +0530

In the world of high-throughput backend services, we often obsess over the usual suspects of performance: database indexing, network latency, and algorithmic complexity. But recently, while debugging our core gateway service (backend-gw), I encountered a bottleneck that defied standard logic.

The service was CPU-bound, yet active heap usage was surprisingly low (~200MB). P99 latency was spiking at random intervals, but database queries were returning in milliseconds.

The culprit was not the business logic. It was memory management. I was effectively running a Denial-of-Service attack on my own runtime.

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.

Understanding Private-Public Key Encryption

Thu, 06 Nov 2025 22:01:23 +0530

In today’s digital world, where secure communication, authentication, and data integrity are non-negotiable, private-public key encryption (also called asymmetric cryptography) plays a foundational role. From HTTPS in your browser to SSH logins, cryptocurrency wallets, and email encryption, this elegant cryptographic system enables trust without prior shared secrets.

In this blog, we’ll dive into:

The core concepts behind asymmetric encryption
How it differs from symmetric encryption
The mathematics (intuitively explained) behind popular algorithms like RSA and ECC
Real-world examples and code snippets
Common use cases and pitfalls

Whether you’re a curious beginner or a seasoned developer brushing up on fundamentals, you’ll find something valuable here.

How to Resolve Huge Git Merge Conflicts Without Losing Your Mind

Thu, 17 Jul 2025 20:56:00 +0000

How to Resolve Huge Git Merge Conflicts Without Losing Your Mind

If you’ve ever been knee-deep in a long-lived branch merge and thought, “this can’t be what version control was meant for”, you’re not alone. Git gives us powerful tools, but resolving large merge conflicts, especially during major migrations or rewrites can feel like surgery without anesthesia.

In this post, we’ll walk through how to approach and resolve massive merge conflicts systematically. Not with hand-wavy advice, but with actual steps, real mental models, and clear visual understanding.

Understanding T and *T method receivers in Go

Sun, 23 Feb 2025 04:33:00 +0000

In Go, method receivers determine whether a method acts on a copy of a value or a reference to it. This choice isn’t just about performance; it affects correctness and behavior, especially when dealing with synchronization primitives (mutex, wait group, etc), slices, and embedded types.

In this post I explore when to use T (a value receiver) vs. *T (a pointer receiver) and why, in most cases, pointer receivers should be the default and preferred.