Writing code is becoming easier.
With AI tools, you can generate APIs, database queries, UI components and even complete features much faster than before.
But building software isn't only about writing code.
The bigger challenge is often how the entire system should work.
Coding a Feature vs Designing a System
Take a URL shortener.
Writing the basic version isn't very difficult:
Client
↓
API
↓
Database
It works.
But what happens when you have millions of requests?
Now you need to think about caching, database bottlenecks, queues, availability, failures, traffic spikes and capacity.
The code might still be simple.
The architecture isn't.
That's where system design becomes important.
The Problem I Had
While learning system design, I noticed that most of the learning was passive.
I would watch someone design a system, understand their decisions and think:
«"Yeah, that makes sense."»
But when I got a blank page and had to design the same system myself, it was much harder.
That's when I thought:
Why isn't there a simple way to actually practice system design instead of just watching it?
So I started building one.
Introducing Devscape
Devscape lets you take a system-design problem and build the architecture yourself.
You get a blank canvas.
You add your services, databases, caches and connections.
Then you submit your design.
Instead of simply showing you a model answer, Devscape evaluates your architecture using a rubric engine.
For example:
Caching ✓
Scalability ⚠
Failure Handling ✗
Capacity Planning ⚠
The interesting part is that I'm not trying to make the grading:
«"You didn't add Redis, so you lost 10 points."»
There isn't always one correct architecture.
A simple architecture can be perfectly valid if it satisfies the requirements.
The goal is to evaluate whether the architecture makes sense for the given requirements and constraints.
You can try it here:
Why I Think This Matters
AI can help us write code much faster.
But someone still needs to decide:
- How the system should be structured
- Where the bottlenecks will be
- How it should handle failures
- How it should scale
- Which trade-offs are worth making
As writing code becomes easier, I think these decisions become even more important.
That's what I'm trying to explore with Devscape.
It's still early, and I'm actively improving the rubric engine.
If you try it, I'd genuinely appreciate your feedback — especially if you think the grading is wrong.
Have recommendations or thoughts? Feel free to share them in the comments!
Want to know more about me or get in touch? Visit my website
Keep coding and exploring ❤️
