Stop guessing.
Start designing systems.
A 2-day live workshop where you'll learn to architect software like a senior engineer. Hands-on projects, real trade-offs, expert feedback.
Next: Mar 26–27 · 1–5 PM PT / 4–8 PM ET · 2 days · Live & hands-on · Limited to 20 seats
See the ScheduleYou can build features. But can you design systems?
You ship code every day, but you're not growing. You can close a ticket. You know your framework. But when someone asks you to design something from scratch — to decide which database, which architecture, which trade-offs — you freeze. You've been building, but you haven't been engineering.
You're stuck between junior and senior. You've outgrown beginner tutorials. You don't need another "Intro to X" course. But the gap between where you are and senior-level thinking feels huge. System design, architecture decisions, trade-off analysis — nobody teaches these in a structured way.
AI amplifies your output, but not your judgment. You use Copilot. You prompt Claude. You ship faster than ever. But AI can't tell you whether you're building the right thing the right way. The developers who thrive aren't the ones who type fastest — they're the ones who think clearest.
Two days. Five levels of thinking.
This workshop is designed around progressive skill-building — you advance from understanding concepts to making real design decisions. No passive lectures. Every session demands output.
-
Build Your Mental Models
Learn the mental models. Identify architecture patterns, recall design principles, explain trade-offs in your own words.
-
Write Real Code
Implement in real code. Take a concept and use it to solve a design problem in a working codebase.
-
Read Any System
Break down existing systems. Compare architecture options, trace data flow, spot where designs succeed or fail.
-
Make Confident Decisions
Make and defend decisions. Assess competing approaches, critique architectures, and justify your choices under review.
-
Design From Scratch
Design a system from scratch. Architect a solution to a set of requirements and present and defend your design.
Two days. One skill you'll use forever.
Each day is a half-day session (4 hours) mixing live instruction and hands-on exercises. You’ll leave with a system you designed and can explain.
Foundations & Patterns
4 hours · Morning session- Monoliths, modular monoliths, and microservices
- Layered, clean, and hexagonal architecture
- Reading and drawing system diagrams
- Repository, Strategy, Observer, Factory in real code
- SOLID principles through refactoring exercises
- Recognizing over-engineering vs. under-engineering
Exercise: Diagram an open-source system and refactor a tangled codebase
Trade-Offs & Design Challenge
4 hours · Morning session- Break down a production architecture (case study)
- Evaluate trade-offs: consistency vs. availability, simplicity vs. flexibility
- Using AI to explore design alternatives faster
- Design a system from a set of real-world requirements
- Walk through your architecture end-to-end
- Defend your trade-offs with instructor feedback
Deliverable: A system design you architected and can explain to anyone
What workshop attendees say
"Two days completely rewired how I think about code. I used to just build features — now I actually consider the architecture first. My tech lead noticed within a week."
Daniel T. Mid-Level Developer, 3 yrs exp.
"The design challenge on Day 2 was the highlight. Walking through my architecture and getting real feedback from the instructor — that’s something you can’t get from a video course."
Aisha R. Full-Stack Developer, 2 yrs exp.
"As a junior trying to level up fast, this was exactly what I needed. The progressive structure meant I wasn’t just memorizing patterns — I was building actual design judgment."
Chris N. Junior Engineer, 1 yr exp.
Two days that change how you build software
$1,500
Book early and save. Price goes to $1,500 one week before the event.
One-time payment. Lifetime access to recordings.
- 2 live half-day sessions (4 hours each)
- Hands-on exercises with instructor feedback
- Design challenge with live instructor feedback
- Lifetime access to session recordings
- Workshop Slack channel for your cohort
Full refund if you cancel 7+ days before the workshop.
We run a different topic each month. Coming soon: Testing Strategy & Quality Engineering, Performance & Observability, and Developer Tooling & Automation. Each workshop stands alone — take one or collect them all.
Common questions
What experience level do I need?
You should be comfortable writing code and have built at least one project — even a small one. If you can implement a feature from a ticket, you're ready. Ideal for developers with 1–4 years of experience, or ambitious juniors who want to skip the slow path.
What's the time commitment?
Two half-day sessions (4 hours each), typically on a Saturday and Sunday morning. That's 8 hours total. Come prepared to work — this is hands-on, not a lecture series.
What language or framework does the workshop use?
Examples use Python and JavaScript/TypeScript, but the concepts are language-agnostic. Architecture patterns, system design, and trade-off analysis apply regardless of your stack. If you work in Go, Ruby, Java, or anything else, the mental models transfer directly.
How is this different from the 90-day course?
The 90-day course teaches you to code from zero. This workshop assumes you already can. Here you'll learn to think about software at a higher level — architecture, design patterns, trade-offs, and system-level reasoning. Think of the course as learning to drive — this teaches you to design the engine.
Do I need to attend all the workshops?
Each monthly workshop is a standalone topic. Take whichever ones match the skills you want to build. System design this month, testing strategy next month, performance the month after. No prerequisites between them.
What's the refund policy?
Full refund if you cancel 7 or more days before the workshop. Within 7 days, we'll transfer your seat to the next cohort instead. Sessions are recorded, so you'll have lifetime access either way.