Engineering Blog

Software writing is most useful when it preserves the reasoning that code alone cannot: the constraint that shaped a boundary, the failure that invalidated an assumption, the trade-off hidden behind a clean interface, or the operational detail that made a design survive production.

I’m Ayush Basak, a CTO and systems architect in Kolkata. These essays cover backend engineering, databases, distributed systems, infrastructure, and production AI.

Start with a problem you are solving:

A dependency keeps failing: bounded retries in TypeScript and deadline budgets.
A database needs to change safely: zero-downtime PostgreSQL migrations.
A cross-region workflow needs ordering: external consistency and TrueTime.
Multiple AI agents need to coordinate: Kiro Flock and shared-state coordination.

2026

Database Credential Rotation: How to Replace Secrets Without Breaking Connection Pools

Kafka Poison Messages: Dead-Letter Queues Without Silent Data Loss

PostgreSQL Deadlocks: Lock Ordering, Transaction Retries, and Safe Recovery

RAG Access Control: What Happens After Document Permission Is Revoked?

S3 Presigned Uploads: Ownership, Overwrites, and Safe Finalization

BM25 From First Principles: The Math, the Index, and Production Ranking

Continuous Batching Is a Scheduling Policy

Refresh-Token Rotation Is a Replay Detector

QUIC Migration Is Not Session Continuity

S3 Multipart Uploads Need Garbage Collection

PostgreSQL HOT Updates Are a Physical Design Contract

Technical Decision Models Compound

AI-Generated Code Creates Review Debt

RAG Quality Starts with Retrieval Evidence

Embedding Upgrades Are Data Migrations

gRPC’s HTTP/2 Transport Is Not the Reliability Model

Copy-on-Write Moves Cost to the First Mutation

Product Quantization Is a Recall–Memory Contract

Bloom Filters Turn Memory into an Error Budget

Adding Kafka Partitions Changes the Ordering Contract

Heartbeats Measure Silence, Not Failure

Cursor Pagination Is a Consistency Contract

OpenTelemetry Baggage Is Untrusted Input

A PodDisruptionBudget Is a Maintenance Contract

A Read Replica Needs a Freshness Contract

A Webhook Endpoint Is a Durable Inbox

Autoscaling Cannot Recover an Expired Deadline

Your Lock Expired. Your Worker Did Not.

Why a Prepared PostgreSQL Query Gets Slower After Warm-Up

A Shared Cache Key Is a Data-Isolation Boundary

Valid JSON Is Not Permission to Execute

AI Agent Memory Is Governed State

Rate Limiting Is Admission Control

Saga Compensation Is Not Rollback

The OpenTelemetry Collector Is a Loss Budget

PostgreSQL Replication Slots Are Retention Leases

JWT Verification Is a Key-Distribution System

HTTP Early Data Is a Replay Boundary

Filtered Vector Search Is a Recall Budget

Kubernetes Probes Are Failure Policy, Not Health Endpoints

PostgreSQL Synchronous Replication Is a Commit Contract

Prompt Caching Is a Context-Layout Problem

Every PostgreSQL Index Spends a Write-Amplification Budget

Kubernetes Termination Is a Distributed Protocol

Kafka Exactly-Once Stops at the Side-Effect Boundary

PostgreSQL Checkpoints Are Latency Events, Not Maintenance Events

Tail Sampling Is a Memory Budget Disguised as an Observability Feature

DNS Failover Is a Bounded-Staleness Protocol

Strongly Consistent Object Storage Still Needs Concurrency Control

A Kafka Rebalance Is a Coordination Protocol, Not a Consumer Restart

PostgreSQL Vacuum Is Concurrency Control, Not Housekeeping

A Raft Write Is Not Committed Just Because Most Replicas Have It

External Consistency Explained: Spanner, TrueTime, and Commit Wait

Durable Workflows Do Not Remove the Need for Idempotency

LLM Serving Is KV-Cache Capacity Planning

Kubernetes Availability Is Placement Plus Disruption Policy

Serializable Isolation Is a Retry Protocol, Not a Checkbox

AI Inference Routing Is Capacity Control

Data Retention Is a System Design Problem

Incident Command Is a Distributed System

Build vs Buy Is an Exit-Cost Decision

Architecture Decisions Need Expiry Dates

Production AI Needs Release Gates, Not a Trust Score

Kubernetes Requests Are an Economic Model

Tenant Isolation Should Not Depend on Every WHERE Clause

An Error Budget Should Change the Roadmap

Scale the Blast Radius, Not Just the Fleet

Feature Flags Are Production State

Verify What You Deploy

Cache Invalidation Is a Consistency Protocol

PostgreSQL Connections Are a Capacity Budget

Control Planes Must Fail Quietly

Cloud Cost Is an Architecture Metric

AI Evals Are Release Engineering

Evolve APIs Without Flag Days

Design Service Identity Before Buying a Service Mesh

Backups Do Not Prove Recoverability

Change Data Capture Is a Recovery Contract

Durable AI Agents Need Workflow Semantics, Not Chat Loops

Tenant Isolation Is a Data Model, Not a WHERE Clause

Queues Hide Overload Until Recovery Becomes Impossible

Your Timeout Budget Is an Architecture Decision

AI Agents Need a Control Plane, Not a Larger Prompt

Observability Is a Data Contract, Not a Dashboard Purchase

The Transactional Outbox Is Not the Delivery Guarantee

PostgreSQL Logical Replication Failover: The Slot Is Part of Your Recovery Plan

PostgreSQL Zero-Downtime Schema Migrations: A Production Guide

A Modern PostgreSQL JDBC Driver Built for Virtual Threads and Native Protocols

Transpiling Multi-Language DB Functions to PL/pgSQL with plx

SynchDB 1.4: Oracle CDB Support and Secured FDW Snapshots

PostgreSQL Minor Updates: CVE-2026-6464 and Index Maintenance

Kiro Flock Explained: Multi-Agent Coordination with S3

KYAML in Practice: Explicit Kubernetes Manifests Without a Migration

The Cost of Complexity

Building Microservices That Fail Gracefully

Thinking Through Offline-First Payments

Why Rust Fits Infrastructure Work

Building AI Products for Accessibility

From Repository to Real Product

>