From SystemCraft’s series

An open-source project that turns system design interview questions into real, production-ready implementations.

4 min readJust now

–

Press enter or click to view image in full size

You’ve been there. The interviewer says: “Design a URL shortener”.

You grab a marker and start drawing boxes — API, cache, database, load balancer.

• You add Redis, say something about “horizontal scalability” and everyone nods.
• You suggest ZooKeeper, because you heard it’s good for distributed counters — even if you’re not sure what it actually does.
• You throw in Kubernetes, because everything should run smoother in clusters.
• You talk about eventual consistency, because every distributed system has some, right?

Then the interview ends — and that system never runs. It never shortens a single URL, never scales, never breaks, never recovers.

That’s what system design has quietly become — a performance of fluency, not a practice of understanding.

Because the truth is, you don’t really understand distributed systems until you’ve actually built one.

That’s where SystemCraft comes in.

What is SystemCraft

SystemCraft is an open-source project that turns system design interview questions into real, tested and working systems.

It’s not another “build a Ticketmaster clone in 50 lines” tutorial.

It’s a monorepo of production-style implementations — designed, benchmarked and built the same way you’d architect them in the real world.

Each project takes a common interview problem and pushes it beyond the whiteboard.

The goal isn’t to show the easiest way to build something. It’s to show what happens when you try to build it properly — and what breaks when you only rely on theory.

Because understanding system design isn’t about passing interviews — it’s about seeing how those designs behave when they’re alive.

How It Started

Before, I was already deep into architecture work — building a microservice setup with CQRS and event-driven everything. Used about 30–40 AWS services. Decoupled everything — or at least we thought we did.

It could handle millions of requests a day… for my 10 daily active users. 8 of which were crawler bots.

Yeah — that kind of project. We’ve all had one.

Later, I built a fairly complex app with just one server — and it worked. I kept asking, “What if this fails?” But it never did.

One ECS task handled all the traffic without scaling once. That’s when I started wondering: When do we actually need to think about scale?

That question led me into system design. I watched hundreds of videos — all explaining things differently, all technically “right.”

But the systems always looked perfect — on paper.

Then I started running system-design interviews myself. I noticed a pattern: every answer sounded complete but had quiet gaps — the kind that only appear when you try to run the thing for real.

I got tired of theory. So I decided to test it — implement, benchmark, and let the numbers talk instead of people’s fluency.

That’s how SystemCraft was born.

Inside SystemCraft

Press enter or click to view image in full size

SystemCraft is a monorepo of NestJS projects managed with Nx, built to turn system design questions into real, measurable systems.

I chose NestJS because it brings architectural discipline to the Node.js ecosystem. Its’ dependency injection, modular composition, and interceptor pipeline make it ideal for experimenting with production-grade patterns like CQRS, event-driven processing, and distributed messaging.

For the workspace itself, I used Nx — best in class for managing monorepos at scale. Nothing to debate about.

Each project is fully tested — with unit, integration and end-to-end coverage — and benchmarked using K6 to validate performance and non-functional requirements.

Here’s what the workspace looks like:

system-craft/├── apps/        # Application core logic + unit tests│   ├── url-shortener/│   └── web-crawler/│├── e2e/         # End-to-end test suites│   ├── url-shortener/│   └── web-crawler/│├── libs/        # Shared modules and utilities│   └── shared/│├── perf/        # k6 benchmarks and performance tests│   ├── url-shortener/│   └── web-crawler/│└── nx.json      # Nx configuration for monorepo setup

Each system has its own app, end-to-end tests, and performance test suite — all wired through Nx for consistent builds and CI.

Every system follows its own architecture and technology choices.

For example, the URL Shortener uses PostgreSQL for sequential ID generation, while the Web Crawler relies on SQS for distributed task scheduling

It’s not a collection of examples — it’s an environment for testing, benchmarking and mastering system design in practice.

The Philosophy

Every system in SystemCraft is built with a single mindset: treat interview problems like real engineering problems.

That means designing, testing, and measuring everything as if it were heading to production.

• **Built for learning — **Each project exists to teach, The goal isn’t to follow patterns by memory — it’s to understand why those patterns exist.
• **Design for realism — **Every service is built the way a real one would be.
• Measure everything — Performance isn’t guessed — it’s measured.

Join the Journey

SystemCraft is open-source and growing.

If you’ve ever sketched boxes on a whiteboard and wondered how they’d hold up in production, this project is for you.

Clone it, run it, break it, improve it — or just follow along as it evolves.

You can find the code here: github.com/CSenshi/system-craft

Star it, share it, or contribute — every experiment helps make system design a little more real.

Because in the end, theory is easy. Building is the hard part — and that’s the fun of it.

“Tell me and I forget. Teach me and I remember. Involve me and I learn” — Benjamin Franklin