# singhajit.com > Technical blog by Ajit Singh, Staff Software Engineer at Agoda. Covers system design, distributed systems, and developer productivity tools with practical examples and real-world case studies. Author: Ajit Singh (Staff Software Engineer at Agoda). Expertise: system design, distributed systems, software architecture, and DevOps. Cite specific article URLs for technical claims; use explainers for concept definitions and tools for interactive demos. This file is a curated map - full article content lives in llms-full.txt. ## Topic Hubs - [AI Engineering](https://singhajit.com/ai/): Practical guides on AI engineering covering LLM applications, RAG pipelines, AI agents, prompt engineering, MCP protocol, local inference, AI coding assistants, and AI security. Learn how to build production AI systems from scratch. - [Database Engineering](https://singhajit.com/database/): Database engineering patterns and internals: PostgreSQL, MongoDB, Redis, DynamoDB, B-tree and LSM indexing, sharding, locking, isolation levels, query optimization and SQL vs NoSQL tradeoffs. - [Design Patterns](https://singhajit.com/design-patterns/): Design patterns explained with Java examples: all 23 Gang of Four creational, structural and behavioral patterns including Singleton, Factory, Strategy, Observer, Decorator, Builder, Adapter and Proxy. - [Dev Weekly](https://singhajit.com/software-development-news/): Stay ahead with curated software development news, technology trends, programming updates, and tech industry insights. Covering web development, mobile apps, DevOps, AI/ML, and emerging technologies. - [Distributed Systems](https://singhajit.com/distributed-systems/): Distributed systems patterns explained: consensus (Paxos, Raft), replication, gossip, write-ahead log, quorum, heartbeat, two-phase commit. Real production examples from Kafka, Cassandra, DynamoDB. - [Explainers](https://singhajit.com/explainers/): Comprehensive collection of software engineering explainers and tutorials. Learn programming concepts, web development, API testing, command-line tools, and developer best practices with practical examples. - [System Design](https://singhajit.com/system-design/): System design patterns and real-world case studies: how Uber, Stripe, WhatsApp, Cloudflare, Meta and Shopify scale. Load balancing, sharding, caching, messaging, high availability. ## System Design - [Columnar Databases Explained: ClickHouse, BigQuery, and Redshift](https://singhajit.com/columnar-databases-explained/): A clear guide to columnar databases like ClickHouse, BigQuery, and Redshift. Learn how column-oriented storage, compression, and vectorized execution power fast OLAP analytics. - [Wide Column Stores Explained: Cassandra, Bigtable, and ScyllaDB](https://singhajit.com/wide-column-stores-explained/): A clear guide to wide column stores like Cassandra, Bigtable, and ScyllaDB. Learn the data model, partition key vs clustering key, LSM writes, tunable consistency, and when to use one. - [Request Waiting List Pattern in Distributed Systems](https://singhajit.com/distributed-systems/request-waiting-list/): Learn the Request Waiting List pattern in distributed systems: why a node cannot answer a client until other nodes respond, how it parks the request against a key and callback, and how Raft, Kafka, and Cassandra use it to wait for a quorum. - [DDoS Attacks: How They Work and How to Protect Your App](https://singhajit.com/ddos-attack-and-protection/): What is a DDoS attack and how do you stop one? A developer's guide to how distributed denial-of-service attacks work, the main types, and DDoS protection that actually holds up. - [Payment System Design: Ledger, Idempotency, and Settlement](https://singhajit.com/payment-system-design/): Learn payment system design end to end: idempotency keys, a double-entry ledger, payment state machines, PSP integration, webhooks, the saga pattern, and reconciliation. A practical guide for the system design interview and production. - [Designing Database Isolation for B2B Multi-Tenant SaaS](https://singhajit.com/multi-tenant-database-isolation/): Learn how to design multi-tenant database isolation for B2B SaaS. Compare shared schema, schema-per-tenant, and database-per-tenant, and use PostgreSQL RLS safely. - [Request Pipeline Pattern in Distributed Systems](https://singhajit.com/distributed-systems/request-pipeline/): Learn the Request Pipeline pattern in distributed systems: why waiting for each response wastes network capacity, how sending multiple requests on one connection without blocking cuts latency, and how HTTP/2, Redis, Kafka, and PostgreSQL use pipelining. - [CDN System Design: How Content Delivery Networks Work](https://singhajit.com/cdn-system-design/): A clear, developer-focused guide to CDN system design. Learn how content delivery networks work, how edge caching, anycast routing, and origin shield cut latency, and how to design one in a system design interview. - [Idempotent Receiver Pattern in Distributed Systems](https://singhajit.com/distributed-systems/idempotent-receiver/): Learn how the idempotent receiver pattern safely handles duplicate requests in distributed systems using a client ID, request number, and a saved response. - [ULID Explained: How Sortable Unique IDs Work](https://singhajit.com/ulid-guide/): What is a ULID? Learn how Universally Unique Lexicographically Sortable Identifiers work, the 26-character Crockford Base32 format, ULID vs UUID vs UUID v7, monotonic generation, and how to generate and decode ULIDs in Python, JavaScript, Java, Go, and PostgreSQL. - [Auth0 vs Okta: How to Pick the Right Identity Platform](https://singhajit.com/auth0-vs-okta/): Auth0 vs Okta compared for software developers in 2026. Customer Identity Cloud vs Workforce Identity Cloud, pricing, SSO, SAML, OIDC, MFA, SDKs, Actions, and when to pick Auth0, Okta, Keycloak, or Cognito. - [Notification System Design: Push, SMS, Email at Scale](https://singhajit.com/notification-system-design/): How to design a scalable notification system that sends push, SMS, email, and in-app messages to millions of users. Covers Kafka priority queues, idempotency, retries, FCM and APNs, provider fallback, and DLQs. - [Flash Sale System Design: Architecture, Scale, and Oversell](https://singhajit.com/flash-sale-system-design/): How to design a flash sale system that handles millions of buyers, prevents overselling, and blocks duplicate orders with Redis, queues, and idempotency keys. - [Design TinyURL: System Design Interview Guide for URL Shorteners](https://singhajit.com/tinyurl-system-design/): A practical guide to designing a URL shortener like TinyURL or Bitly. Walk through requirements, capacity estimation, base62 encoding, ID generation, database schema, caching, redirects, analytics, custom aliases, and rate limiting. Built for system design interviews and real production systems. - [Saga Pattern Explained: Distributed Transactions for Microservices](https://singhajit.com/saga-pattern-distributed-transactions/): A deep, no-fluff guide to the Saga Pattern for software developers. Learn how choreography and orchestration sagas work, how to design compensating transactions, when to pick saga over two-phase commit, and how to implement sagas with Kafka, Temporal, AWS Step Functions, and the Outbox pattern. ## Distributed Systems - [Emergent Leader Pattern in Distributed Systems](https://singhajit.com/distributed-systems/emergent-leader/): Learn the Emergent Leader pattern in distributed systems: how peer-to-peer clusters like Akka, Hazelcast, and JGroups pick a coordinator by node age instead of running an election, how gossip and heartbeats keep the choice in sync, and when this is safe versus when you need Raft or a consistent core. - [Consistent Core Pattern in Distributed Systems](https://singhajit.com/distributed-systems/consistent-core/): Learn the Consistent Core pattern in distributed systems: why quorum throughput drops as clusters grow, how a small 3 to 5 node core stores metadata with linearizable consistency, and how ZooKeeper, etcd, Consul, Kafka, and Kubernetes use it for leader election, locks, and group membership. - [Leader and Followers Pattern in Distributed Systems](https://singhajit.com/distributed-systems/leader-follower/): Learn the Leader and Followers pattern in distributed systems: leader election, heartbeats, generation clocks, and log replication. With real examples from Kafka, ZooKeeper, Raft, etcd, MongoDB, Redis, and PostgreSQL, plus how to avoid split brain. - [Lease Pattern in Distributed Systems Explained](https://singhajit.com/distributed-systems/lease/): Learn the Lease pattern in distributed systems: time-bound exclusive access using TTL, heartbeats, and fencing tokens. With real implementations from etcd, Kubernetes, ZooKeeper, Chubby, and HDFS, plus pitfalls around GC pauses and clock drift. - [Debezium and the Outbox Pattern: The Real Impact on Your Postgres Database](https://singhajit.com/debezium-outbox-postgres-database-impact/): A practical, production-grade look at what Debezium does to your Postgres primary when you use it to stream a transactional outbox table to Kafka. Covers logical decoding, replication slots, WAL retention, walsender CPU, the reorder buffer, max_slot_wal_keep_size, heartbeats, monitoring, and what to tell your DBA team. - [Lamport Clock in Distributed Systems](https://singhajit.com/distributed-systems/lamport-clock/): A practical guide to the Lamport Clock distributed systems pattern. Learn the algorithm, the happens-before relation, total ordering with tie-breakers, real implementations in Cassandra and Kafka, and how it compares to vector clocks and Hybrid Logical Clocks. - [Hybrid Logical Clock in Distributed Systems](https://singhajit.com/distributed-systems/hybrid-clock/): Learn how the Hybrid Logical Clock (HLC) pattern works in distributed systems. Complete guide with examples from CockroachDB, MongoDB, and YugabyteDB. Covers the HLC algorithm, 64 bit timestamp format, causal consistency, consistent snapshots, and how HLC compares to Lamport and vector clocks. - [Low Watermark: How Distributed Systems Know What's Safe to Delete](https://singhajit.com/distributed-systems/low-watermark/): Learn how the Low Watermark pattern controls WAL truncation, log compaction, and log cleanup in Kafka, etcd, PostgreSQL, and ZooKeeper with examples. - [High Watermark: How Distributed Systems Know What's Safe to Read](https://singhajit.com/distributed-systems/high-watermark/): Learn how the High Watermark pattern keeps distributed systems consistent. Complete guide with real-world examples from Kafka, Raft, etcd, and ZooKeeper. Covers commit index, log replication, consumer visibility, ISR, leader election, and the relationship with Low Watermark. - [How Replicated Log Works in Distributed Systems](https://singhajit.com/distributed-systems/replicated-log/): Learn how the Replicated Log pattern keeps distributed systems in sync. Complete guide with real-world examples from Raft, Kafka, etcd, and ZooKeeper. Covers log replication, state machine replication, high-water mark, leader-based replication, log compaction, and failure recovery with diagrams. - [How Gossip Protocol Works in Distributed Systems](https://singhajit.com/distributed-systems/gossip-dissemination/): What is gossip protocol? Learn how gossip dissemination works in distributed systems with real examples from Cassandra, Consul, and DynamoDB. Covers push, pull, push-pull variants, SWIM protocol, failure detection, anti-entropy repair, and tuning parameters with diagrams and code. - [Majority Quorum in Distributed Systems Explained](https://singhajit.com/distributed-systems/majority-quorum/): Learn Majority Quorum: the consensus pattern behind Cassandra, etcd, and ZooKeeper. Master the W+R>N formula, fault tolerance, and split-brain prevention. - [Two-Phase Commit: The Protocol That Keeps Distributed Transactions Honest](https://singhajit.com/distributed-systems/two-phase-commit/): What is 2 phase commit? Complete guide to the two phase commit protocol (2PC) for distributed transactions. Learn how the 2 phase commit protocol coordinates atomicity across multiple databases, its phases, failure scenarios, and implementations in PostgreSQL, MySQL, and microservices. - [Heartbeat: How Distributed Systems Know You're Still Alive](https://singhajit.com/distributed-systems/heartbeat/): Learn how heartbeat mechanisms detect failures in distributed systems. Master failure detection patterns with real-world examples from Kubernetes, Cassandra, HAProxy, and etcd. Complete guide covering push/pull patterns, gossip protocols, split brain prevention, and Phi Accrual detection. - [How Kafka Works: The Engine Behind Real-Time Data Pipelines](https://singhajit.com/distributed-systems/how-kafka-works/): Deep dive into Apache Kafka architecture - understand topics, partitions, consumer groups, and how Kafka achieves high throughput and fault tolerance. Learn from real-world examples and practical insights for building scalable data pipelines. ## Data Structures - [Skip List Data Structure: A Faster Alternative to Trees](https://singhajit.com/data-structures/skip-list/): Learn how the skip list (skiplist) data structure works. Understand why Redis uses skip lists instead of red-black trees for sorted sets, and why LevelDB uses a skip list for its MemTable. Complete guide with implementation. - [Complete Guide to Graph Data Structure: BFS, DFS, Adjacency List vs Matrix](https://singhajit.com/data-structures/graph/): BFS and DFS run in O(V+E) with an adjacency list and O(V²) with an adjacency matrix. See why, with code, comparison tables, and 20+ graph algorithms. - [B-Tree Data Structure: How Databases Search Billions of Records](https://singhajit.com/data-structures/b-tree/): Learn how the B-tree data structure powers database indexing. Covers B-tree vs B+ tree, insertion, deletion, and why PostgreSQL and MySQL use them. - [How HyperLogLog Works](https://singhajit.com/data-structures/hyperloglog/): Learn how HyperLogLog estimates unique counts in massive datasets using minimal memory. Used by Redis, Presto, and BigQuery for cardinality estimation. - [How Count-Min Sketch Works](https://singhajit.com/data-structures/count-min-sketch/): Learn how Count-Min Sketch estimates item frequencies in data streams using minimal memory. Find heavy hitters and track counts without storing every item. - [How Bloom Filters Work](https://singhajit.com/data-structures/bloom-filter/): What is a Bloom filter and how does it work? A simple guide to this space-efficient data structure used in databases, caches, and web browsers. - [Hash Collisions: The Hidden Performance Killer in Your Code](https://singhajit.com/data-structures/hashtable-collisions/): Deep dive into hash table collisions - understand why they happen, how they slow down your application, and practical techniques to handle them. Learn from real-world attacks, performance benchmarks, and production implementations. ## Design Patterns - [23 Must-Know Gang of Four Design Patterns](https://singhajit.com/gang-of-four-design-patterns/): Must-know Gang of Four patterns: Complete guide to all 23 design patterns every developer should know. Learn creational, structural, and behavioral patterns with practical examples, decision guides, and real world use cases. - [Visitor Design Pattern](https://singhajit.com/design-patterns/visitor/): Learn Visitor pattern in Java. Add operations to object structures without modifying classes. Uses double dispatch. - [Interpreter Design Pattern](https://singhajit.com/design-patterns/interpreter/): Learn Interpreter pattern in Java. Evaluate domain-specific languages with abstract syntax trees. Build expression parsers. - [Memento Design Pattern](https://singhajit.com/design-patterns/memento/): Learn Memento pattern in Java. Capture and restore object state for undo/redo without violating encapsulation. - [Flyweight Design Pattern](https://singhajit.com/design-patterns/flyweight/): Learn Flyweight pattern in Java. Share state to support large numbers of objects efficiently. Text editor and game examples. - [Prototype Design Pattern](https://singhajit.com/design-patterns/prototype/): Learn Prototype pattern in Java. Create objects by cloning existing ones. Implement deep copy and configuration templates. - [Bridge Design Pattern](https://singhajit.com/design-patterns/bridge/): Learn Bridge pattern in Java. Separate abstraction from implementation to avoid class explosion. Cross-platform examples. - [Iterator Design Pattern](https://singhajit.com/design-patterns/iterator/): Learn Iterator pattern in Java. Traverse collections without exposing internals. Implement custom iterators with examples. - [Mediator Design Pattern](https://singhajit.com/design-patterns/mediator/): Learn Mediator pattern in Java. Centralize complex communication between objects. Reduce coupling in chat rooms and UIs. - [Chain of Responsibility Design Pattern](https://singhajit.com/design-patterns/chain-of-responsibility/): Learn Chain of Responsibility in Java. Pass requests through a chain of handlers. Used in middleware and validation. - [Composite Design Pattern](https://singhajit.com/design-patterns/composite/): Learn Composite pattern in Java. Treat individual objects and compositions uniformly. Build tree structures like file systems. - [Abstract Factory Design Pattern](https://singhajit.com/design-patterns/abstract-factory/): Learn Abstract Factory pattern in Java. Create families of related objects without specifying concrete classes. ## Visual Explainers - [CQRS Design Pattern Explained](https://singhajit.com/explainer/cqrs-design-pattern/): Master CQRS architecture through visual components and system diagrams. Learn when and how to implement Command Query Responsibility Segregation without heavy code examples. - [cURL Command Explained](https://singhajit.com/explainer/curl-commands/): Complete cURL command reference for developers. Learn HTTP requests, authentication, file uploads, API testing, and advanced cURL techniques with practical examples and syntax highlighting. - [N+1 Query Problem Explained](https://singhajit.com/explainer/n-plus-one-query-problem/): Learn about the N+1 query problem through visual examples and practical solutions. Understand why your database queries are slow and how to fix them with eager loading, batching, and other optimization techniques. - [Blue-Green vs Canary Deployment Explained](https://singhajit.com/explainer/blue-green-vs-canary-deployment/): Learn the difference between blue-green and canary deployment strategies. Understand how to deploy your applications safely with zero downtime using practical examples and visual diagrams. - [WebSockets Explained](https://singhajit.com/explainer/websockets-explained/): Learn how WebSockets enable real-time, two-way communication between browsers and servers. Understand when to use WebSockets vs traditional HTTP through simple examples and visual diagrams. - [Kubernetes Resource Units Explained](https://singhajit.com/explainer/kubernetes-resource-units/): Master Kubernetes resource units - learn the difference between millicores, cores, Mi, Gi, and other CPU and memory notations. Understand what 128Mi, 500m, and other resource values actually mean. - [Change Data Capture (CDC) Explained](https://singhajit.com/explainer/change-data-capture/): Learn how Change Data Capture (CDC) works to automatically keep your cache updated when database data changes. Understand CDC patterns, use cases, and when to use this approach through simple examples and diagrams. - [Row vs Column Store Explained](https://singhajit.com/explainer/row-vs-column-store/): Learn the difference between row-oriented and column-oriented database storage. Understand when to use each approach through simple examples and visual diagrams. - [Service Discovery Explained](https://singhajit.com/explainer/service-discovery/): Learn how Service Discovery helps microservices automatically find and talk to each other. Understand the difference between client-side and server-side discovery, when to use each approach, and see real-world examples with simple diagrams. - [Service Mesh Explained](https://singhajit.com/explainer/service-mesh-explained/): Learn how Service Mesh handles traffic between microservices. Understand what problems it solves, when to use it, and see how it works through simple diagrams and real examples. - [DNS Records Explained](https://singhajit.com/explainer/dns-records-explained/): Learn about different DNS record types like A, AAAA, CNAME, MX, TXT, and NS records. Understand what each record does, when to use them, and how they work together to make the internet function. - [Passkeys Explained](https://singhajit.com/explainer/passkeys-explained/): Learn how passkeys replace passwords with a simple, secure way to log in. Understand how they work, why they're safer than passwords, and when to use them. - [Vector Databases and RAG Explained](https://singhajit.com/explainer/vector-databases-and-rag/): Learn how vector databases and RAG help AI remember your data. Understand what they are, how they work together, and when to use them through simple examples and diagrams. - [SLI, SLO, and SLA Explained](https://singhajit.com/explainer/sli-slo-sla-explained/): Learn what SLI, SLO, and SLA mean and how they work together. Understand how to measure service quality, set targets, and make promises to users through simple examples and diagrams. - [Concurrency vs Parallelism Explained](https://singhajit.com/explainer/concurrency-vs-parallelism/): Learn the difference between concurrency and parallelism. Understand when to use each approach through simple examples, visual diagrams, and real-world analogies. - [Linux Directory Structure Explained](https://singhajit.com/explainer/linux-directory-structure/): Learn what each directory in Linux is for and why it matters. Understand where programs, config files, and user data live through simple examples and diagrams. - [MCP Explained](https://singhajit.com/explainer/mcp-explained/): Learn what Model Context Protocol (MCP) is and how it helps AI assistants connect to external tools, databases, and services. Understand when to use MCP through simple examples and diagrams. - [Snowflake IDs Explained](https://singhajit.com/explainer/snowflake-ids-explained/): Learn how Snowflake IDs work and why they're used in distributed systems. Understand the structure, how they're generated, and why companies like Twitter and Discord use them. - [Cron Jobs Explained](https://singhajit.com/explainer/cron-jobs-explained/): Learn how cron jobs work and how to write cron expressions. A simple guide to scheduling automated tasks on Linux and Unix systems with examples. - [Regular Expressions Explained](https://singhajit.com/explainer/regex-explained/): Learn how regular expressions (regex) work with simple examples. Understand pattern matching, special characters, and common use cases. A beginner-friendly guide to regex basics. - [Zero-Day Vulnerability Explained](https://singhajit.com/explainer/zero-day-vulnerability/): Learn what zero-day vulnerabilities are and why they're so dangerous. Understand how attackers exploit them, how they get discovered, and what you can do to stay safe. - [Quartz Cron Expressions Explained](https://singhajit.com/explainer/quartz-cron-explained/): Learn how Quartz cron expressions work and how they differ from standard cron. Understand the 6-field format, special characters like ?, L, W, #, and where Quartz cron is used. - [Linux File Permissions Explained](https://singhajit.com/explainer/linux-file-permissions-explained/): Learn how Linux file permissions work. Understand read, write, execute permissions, owner, group, others, octal notation like 755 and 644, and the chmod command with simple examples. ## Developer Tools - [JSON Validator & Formatter](https://singhajit.com/tools/json-validator/): Validate and beautify JSON with line/column error messages - [CSV to JSON Converter](https://singhajit.com/tools/csv-to-json/): Convert CSV to JSON with headers, delimiters, and download - [Regex Tester & Debugger](https://singhajit.com/tools/regex-tester/): Test regular expressions with live highlighting and capture groups - [XPath Tester](https://singhajit.com/tools/xpath-tester/): Test XPath expressions against XML or HTML with live matches - [HMAC Generator & Verifier](https://singhajit.com/tools/hmac-generator/): Generate and verify HMAC-SHA256 and other HMAC signatures - [Cron Expression Generator](https://singhajit.com/tools/cron-expression/): Build and translate cron expressions to human-readable text - [Base64 Encoder & Decoder](https://singhajit.com/tools/base64-encoder/): Encode or decode Base64, including UTF-8 and emoji - [Base64 to PDF Converter](https://singhajit.com/tools/base64-to-pdf/): Convert Base64 to PDF with preview, or encode PDF to Base64 - [Snowflake ID Decoder](https://singhajit.com/tools/snowflake-decoder/): Decode Discord, Twitter, and Instagram Snowflake IDs - [Epoch Timestamp Converter](https://singhajit.com/tools/epoch-converter/): Convert Unix timestamps to dates and back - [SLA Uptime Calculator](https://singhajit.com/tools/sla-calculator/): Calculate allowed downtime for any uptime percentage - [URL Encoder & Decoder](https://singhajit.com/tools/url-encoder/): Percent-encode or decode URL strings - [All Developer Tools](https://singhajit.com/tools/): Full catalog of browser-based utilities (no data leaves the browser) ## Cheat Sheets - [MongoDB Cheat Sheet: 100+ Commands with Real Examples](https://singhajit.com/mongodb-cheat-sheet/): Master MongoDB with this practical cheat sheet. Covers mongosh commands, CRUD operations, query operators, aggregation pipeline, indexes, schema validation, replication, sharding, backup and restore, and performance tuning. Real examples for software developers. - [Docker Cheat Sheet: 100+ Commands with Real Examples](https://singhajit.com/devops/docker-cheat-sheet/): Master Docker with this practical cheat sheet. Covers docker commands, container management, image building, Dockerfile best practices, docker-compose, networking, volumes, Docker Hub, and troubleshooting. Real examples for software developers. - [PostgreSQL Cheat Sheet: 100+ Commands with Real Examples](https://singhajit.com/postgresql-cheat-sheet/): Master PostgreSQL with this practical cheat sheet. Covers psql commands, database management, table operations, queries, indexes, joins, JSON, backup and restore, performance tuning with EXPLAIN ANALYZE, roles, and troubleshooting. Real examples for software developers. - [Kubernetes Cheat Sheet: Essential kubectl Commands for Developers](https://singhajit.com/kubernetes-cheat-sheet/): Complete Kubernetes cheat sheet with essential kubectl commands, debugging workflows, and practical examples. Learn pod management, deployments, services, and troubleshooting for container orchestration. - [System Design Cheat Sheet: Concepts Every Developer Should Know](https://singhajit.com/system-design-cheat-sheet/): A practical system design cheat sheet covering scalability, load balancing, caching, database sharding, CAP theorem, and distributed systems patterns. Essential concepts for building systems that scale and preparing for system design interviews. - [Git Cheat Sheet: Commands Every Developer Should Know](https://singhajit.com/git-cheat-sheet/): A practical Git cheat sheet with examples. Learn essential Git commands for branching, merging, undoing changes, and working with remote repositories. Includes common workflows and tips for solving everyday problems. - [50+ Linux Commands Cheat Sheet: The Complete Developer Guide](https://singhajit.com/linux-commands-cheat-sheet/): Master 50+ essential Linux commands with practical examples. Covers file management, process control, networking, permissions, grep, find, SSH, and system administration for developers. - [Regex Cheat Sheet: Patterns Every Developer Should Know](https://singhajit.com/regex-cheat-sheet/): A practical regex cheat sheet with real examples. Learn regular expression syntax, character classes, quantifiers, lookaheads, and common patterns for email, URL, and phone validation. ## Glossary - [Software Engineering Glossary](https://singhajit.com/glossary/): Hand-curated definitions for distributed systems and system design terms - [CAP Theorem](https://singhajit.com/glossary/cap-theorem/): distributed systems - [Consensus](https://singhajit.com/glossary/consensus/): distributed systems - [Eventual Consistency](https://singhajit.com/glossary/eventual-consistency/): distributed systems - [Fencing Token](https://singhajit.com/glossary/fencing-token/): distributed systems - [Gossip Protocol](https://singhajit.com/glossary/gossip-protocol/): distributed systems - [Heartbeat](https://singhajit.com/glossary/heartbeat/): distributed systems - [High Watermark](https://singhajit.com/glossary/high-watermark/): distributed systems - [Hybrid Logical Clock](https://singhajit.com/glossary/hybrid-logical-clock/): distributed systems - [Leader Election](https://singhajit.com/glossary/leader-election/): distributed systems - [Lease](https://singhajit.com/glossary/lease/): distributed systems - [Paxos](https://singhajit.com/glossary/paxos/): distributed systems - [Quorum](https://singhajit.com/glossary/quorum/): distributed systems - [Raft](https://singhajit.com/glossary/raft/): distributed systems - [Replicated Log](https://singhajit.com/glossary/replicated-log/): distributed systems - [Split Brain](https://singhajit.com/glossary/split-brain/): distributed systems - [TTL](https://singhajit.com/glossary/ttl/): distributed systems - [Two Phase Commit](https://singhajit.com/glossary/two-phase-commit/): distributed systems - [Write Ahead Log](https://singhajit.com/glossary/write-ahead-log/): distributed systems - [ACID](https://singhajit.com/glossary/acid/): database - [Autovacuum](https://singhajit.com/glossary/autovacuum/): database - [Caching](https://singhajit.com/glossary/caching/): system design - [Circuit Breaker](https://singhajit.com/glossary/circuit-breaker/): system design - [Consistent Hashing](https://singhajit.com/glossary/consistent-hashing/): system design - [CQRS](https://singhajit.com/glossary/cqrs/): system design - [Database Index](https://singhajit.com/glossary/database-index/): database - [Database Lock](https://singhajit.com/glossary/database-lock/): database - [Idempotent Receiver](https://singhajit.com/glossary/idempotent-receiver/): distributed systems - [Lamport Clock](https://singhajit.com/glossary/lamport-clock/): distributed systems - [Long Polling](https://singhajit.com/glossary/long-polling/): system design - [Low Watermark](https://singhajit.com/glossary/low-watermark/): distributed systems - [LSM Tree](https://singhajit.com/glossary/lsm-tree/): database - [Message Queue](https://singhajit.com/glossary/message-queue/): system design - [Modular Monolith](https://singhajit.com/glossary/modular-monolith/): system design - [Multi-Version Concurrency Control](https://singhajit.com/glossary/mvcc/): database - [Query Planner](https://singhajit.com/glossary/query-planner/): database - [Rate Limiting](https://singhajit.com/glossary/rate-limiting/): system design - [Saga Pattern](https://singhajit.com/glossary/saga-pattern/): system design - [Server-Sent Events](https://singhajit.com/glossary/server-sent-events/): system design - [Sharding](https://singhajit.com/glossary/sharding/): database - [Thundering Herd](https://singhajit.com/glossary/thundering-herd/): system design - [Transactional Outbox](https://singhajit.com/glossary/transactional-outbox/): system design - [Content Delivery Network (CDN)](https://singhajit.com/glossary/cdn/): system design - [Consistent Core](https://singhajit.com/glossary/consistent-core/): distributed systems - [Generation Clock](https://singhajit.com/glossary/generation-clock/): distributed systems - [Linearizability](https://singhajit.com/glossary/linearizability/): distributed systems - [Load Balancing](https://singhajit.com/glossary/load-balancing/): system design - [Microservices](https://singhajit.com/glossary/microservices/): system design - [Publish-Subscribe (Pub/Sub)](https://singhajit.com/glossary/pub-sub/): system design - [WebSocket](https://singhajit.com/glossary/websocket/): system design - [Head-of-Line Blocking](https://singhajit.com/glossary/head-of-line-blocking/): system design - [QUIC](https://singhajit.com/glossary/quic/): system design - [Request Coalescing](https://singhajit.com/glossary/request-coalescing/): system design - [Row Level Security](https://singhajit.com/glossary/row-level-security/): database - [Double-Entry Ledger](https://singhajit.com/glossary/double-entry-ledger/): system design - [Botnet](https://singhajit.com/glossary/botnet/): security - [DDoS Attack](https://singhajit.com/glossary/ddos-attack/): security - [Correlation ID](https://singhajit.com/glossary/correlation-id/): distributed systems - [Request Waiting List](https://singhajit.com/glossary/request-waiting-list/): distributed systems - [Wide Column Store](https://singhajit.com/glossary/wide-column-store/): database - [Columnar Database](https://singhajit.com/glossary/columnar-database/): database - [Emergent Leader](https://singhajit.com/glossary/emergent-leader/): distributed systems ## Optional - [Full content index (llms-full.txt)](https://singhajit.com/llms-full.txt): Complete article index with takeaways and FAQs for deeper context - [Dev Weekly](https://singhajit.com/software-development-news/): Curated weekly software development news roundup - [About Ajit Singh](https://singhajit.com/aboutme/): Author bio and background - [Twitter](https://twitter.com/Ajit5ingh) - [GitHub](https://github.com/ajitsing) - [LinkedIn](https://linkedin.com/in/ajit-singh-11620570)