Arpit Bhayani

Tech debt has rules.

Every process a software team runs was built to manage a scarce resource.

A company runs smoothly when people can get stuff done without hunting for information.

G-Eval is a reference-free evaluation framework that uses large language models to assess the quality of generated text.

Every AI workflow is a dependency problem.

Most of us building AI applications spend the bulk of their time on the LLM - picking the right model, tuning the prompt, evaluating output quality.

If you have ever taped together a cron job, message queue, a database table for state, and a retry loop - only to watch the whole thing break during a network blip at 2am - you already understand the problem Temporal solves.

Most of us build RAG the same way: follow a tutorial that embeds a handful of PDFs, stores the vectors in a local Chroma instance, and chains everything together with LangChain (if that's still a thing).

Role tagging is not cosmetic.

If you have used ChatGPT, Gemini, or Claude, you have already formed an intuition about what these systems do.

You have a monolith, and you are proud of it.

There is a specific kind of debugging session that haunts ML engineers: the one where your model worked brilliantly on 20 features, so you added 200 more, and now it produces garbage.

There is an implicit contract at the foundation of every database architecture decision you have ever made.

There is a particular kind of respect reserved in engineering for the algorithm that outlives its era.

When you write a SQL query with a JOIN clause, you probably do not think much about what happens next.

That is the half-life of knowledge in computer science and software engineering - the time it takes for half of what you know to be replaced by better tools, approaches, or understanding.

Distributed databases face an interesting challenge: how do you ensure that multiple servers scattered across different machines, data centers, or even continents agree on the order and outcome of database transactions?

MySQL replication enables data synchronization across databases, powering read scaling and even some complex distributed architectures.

A Bloom filter is a probabilistic data structure that answers a very specific question - have I seen this thing before?

Time seems simple.

Partitions sit right in the middle of how Kafka works.

Recommendation engines, image retrieval platforms, document matching services, and RAG pipelines all rely on finding the nearest neighbors to a given query vector in high-dimensional space.

At the core of the attention mechanism in LLMs are three matrices: Query, Key, and Value.

When you enter a prompt into an LLM, the model converts your text into numbers, processes them, and returns a response one token at a time.

Concurrent programming is one of the most interesting and challenging aspects of software engineering.

In distributed systems, one of the fundamental challenges is knowing whether a node or service is alive and functioning properly.

Apache Cassandra is a distributed database designed for high availability and horizontal scalability.

One of the most fundamental design decisions in Redis replication is that it's push-based rather than pull-based.

Content Delivery Networks (CDNs) content replication is far more nuanced than most engineers realize.

When Google introduced gRPC in 2015, one of the most significant architectural decisions was building it on top of HTTP/2 rather than the widely adopted HTTP/1.1.

Everything we interact with today is a "distributed system".

Database deadlocks are one of the most challenging concurrency issues encountered in production systems.

While we write code thinking about algorithms and data structures, the CPU is quietly making millions of decisions about what data to keep close and what to evict from its precious cache memory.

While strong consistency might seem like the obvious choice - given it keeps the data perfectly synchronized at all times - the reality is that eventual consistency has become the preferred approach for most large-scale distributed systems.

DNS is one of the most critical pieces of internet infrastructure, quietly translating human-readable domain names into IP addresses billions of times per day.

Craft effective engineering OKRs with this practical guide.

Most engineers encounter cardinality estimation the same way: they get paged because a COUNT(DISTINCT userid) query is killing the database, and someone suggests HyperLogLog.

Is it time for a career change?

Explore AWS Lambda's efficient scaling - block-level loading, deduplication with encryption, & erasure coding for low-latency container startups.

Explore GoogleSQL's new pipe syntax for SQL - Improves readability, extensibility, and debugging with operators like ASSERT and LOG.

Explore NanoLog's high-performance logging - compile-time optimization, lock-free buffers, and lightweight encoding for nanosecond speed.

Explore Twitter's recommendation system - in-memory graph processing with Cassovary, random walks, and SALSA for user suggestions.

Ace your system design interview!

Stuck as a software engineer?

Solve the Knapsack problem with a Genetic Algorithm!

Explore LFSRs, a simple & efficient pseudorandom number generator widely used in microcontrollers.

Explore indexing strategies for partitioned databases, focusing on local and global secondary indexes.

Partitioning - Learn how to scale your database reads and writes by horizontally partitioning your data.

Learn database partitioning!

Explore leaderless replication - a fault-tolerant, strongly consistent data replication strategy.