The Cruxible Blog
Practical writing on coding interviews, system design, and getting genuinely good — the same skills you train in the arena.
Dynamic Programming: how to recognize it in 60 seconds
Most people fail DP problems before writing a line because they do not spot the pattern. Here is a fast recognition checklist and the path from recurrence to working code.
Acing the system design interview: a 45 minute playbook
A minute-by-minute playbook for the system design interview, from clarifying requirements to scaling, so you spend your 45 minutes signaling exactly what gets you hired.
The CAP Theorem, Finally Explained Without the Jargon
CAP is not about choosing two of three. It is about what you do when the network breaks. Here is the version that actually helps you design systems.
Graphs for Interviews: BFS vs DFS and When to Use Which
A practical guide to choosing between breadth-first and depth-first search in coding interviews, with clear rules for when each one wins.
Rate Limiting Algorithms: Token Bucket vs Leaky Bucket vs Sliding Window
A clear, practical comparison of the four rate-limiting algorithms — token bucket, leaky bucket, fixed window, and sliding window — with the trade-offs that decide which one to ship.
From Bronze to Grandmaster: A Ranked Path Through CS Fundamentals
Motivation dies without progress you can see. A rating that climbs from Bronze to Grandmaster turns 'study CS' into a game you actually want to keep playing.
How to Actually Get Good at LeetCode (Without Grinding 500 Problems)
Volume is the trap. The people who pass interviews practice fewer problems, deliberately — spaced, varied, and graded. Here's the system.
Machine learning for engineers: the 20 percent you actually need
Skip the PhD detour. The core machine learning concepts every working engineer should know to ship features and read ML code without getting lost.
Idempotency: The One Idea That Saves Payment Systems
Networks retry, and retries double-charge customers unless your system is idempotent. Here is how idempotency keys turn unsafe retries into safe ones.
Sliding Window: From Brute Force to Linear Time
Turn nested-loop substring and subarray problems into clean linear-time solutions with the sliding window pattern, fixed and variable.
Binary Search done right: beating the off-by-one trap
Binary search is simple in theory and brutal in practice. A template-driven approach kills the off-by-one bugs and unlocks the harder search-on-answer problems.
Big-O in Practice: The Only Complexity Cheat Sheet That Sticks
Stop memorizing a table you forget. Learn to see the shape of an algorithm — constant, log, linear, quadratic — and you'll never blank on complexity in an interview again.
Caching Strategies and the Cache-Invalidation Trap
A practical guide to caching patterns — cache-aside, write-through, write-back — and how to dodge the stale-data traps that make cache invalidation famously hard.
System Design Interviews: A Field Guide to the 12 Core Building Blocks
Most system design questions are remixes of the same dozen components. Learn the building blocks — load balancers, queues, caches, CDNs — and you can reason about almost anything.
Hash Maps: the O(1) superpower
Hash maps turn linear scans into constant-time lookups. Learn when to reach for them, the patterns interviewers actually test, and the gotchas that bite seniors.
Can You Still Beat the Machine? Practicing Coding in the Age of AI
AI can autocomplete your code — but interviews, system design, and real engineering still reward judgment. Here's how to train the skills models can't fake for you.
What is an LLM, really? A mental model for developers
A no-hype mental model of how large language models actually work, written for engineers who want to build with them instead of just prompt them.
Database Indexes: Why Your Query Is Slow
A slow query is almost always a missing or misused index. Here is how indexes actually work, when they help, and the traps that silently disable them.
Designing a URL Shortener: A System Design Walkthrough
A practical, senior-engineer walkthrough of designing a URL shortener: key generation, the read-heavy data model, caching, and the scaling decisions interviewers actually probe.
Two Pointers: One Pattern That Solves Dozens of Problems
Master the two pointers technique and unlock a single mental model that cracks pair sums, palindromes, dedup, and merging in linear time.