r/softwarearchitecture • • Sep 28 '23 Heartwarming

Discussion/Advice [Megathread] Software Architecture Books & Resources

591 Upvotes

This thread is dedicated to the often-asked question, 'what books or resources are out there that I can learn architecture from?' The list started from responses from others on the subreddit, so thank you all for your help.

Feel free to add a comment with your recommendations! This will eventually be moved over to the sub's wiki page once we get a good enough list, so I apologize in advance for the suboptimal formatting.

Please only post resources that you personally recommend (e.g., you've actually read/listened to it).

note: Amazon links are not affiliate links, don't worry

Roadmaps/Guides

Books

Engineering, Languages, etc.

Software Design

The Art of Architecture

Enterprise Architecture

Career

Blogs & Articles

Podcasts

  • Thoughtworks Technology Podcast
  • GOTO - Today, Tomorrow and the Future
  • InfoQ podcast
  • Engineering Culture podcast (by InfoQ)

Misc. Resources


r/softwarearchitecture • • Oct 10 '23

Discussion/Advice Software Architecture Discord

22 Upvotes

Someone requested a place to get feedback on diagrams, so I made us a Discord server! There we can talk about patterns, get feedback on designs, talk about careers, etc.

Join using the link below:

https://discord.gg/ccUWjk98R7

Link refreshed on: December 25th, 2025


r/softwarearchitecture • • 3h ago

Discussion/Advice Modular monolithic vs. microservices architecture from my own experience

8 Upvotes

The story started when I started working for a company in Canada. Shortly after joining, I was assigned a task to build a microservice.

The company had excellent documentation, clear architectural guidelines, and a well-structured codebase.

I implemented the service, integrated it with the API Gateway using Ocelot, and prepared for demo day.

The demo went incredibly well. For a moment, I felt like a hero. 😄

Of course, my pull request wasn't perfect. There were review comments, SonarQube wasn't happy with some of my naming conventions, and a few code smells needed attention.

But I genuinely enjoyed the experience.

I learned a lot about RabbitMQ, Ocelot routing, API gateways, rate limiting, and how distributed services communicate.

I fell in love with microservices. Then I joined a company in Romania.

Different company. Different architecture.

This time, the backend was a modular monolith, and the frontend was an Angular monorepo.

The codebase was massive. Understanding the entire application wasn't easy, especially as someone joining an established project.

And I started missing microservices.

I missed those smaller, independently understandable services. I missed the feeling of working on one focused component without navigating a huge codebase.

At that point, I genuinely believed microservices were the better architectural choice.

All of this happened before the AI coding era.

Fast-forward a few years.

I had become much more experienced with Angular, .NET, design patterns, and software architecture.

I joined another company in Cyprus.

We had a large, complex project, and this time I had the opportunity to influence its architecture.

I proposed microservices. The proposal was approved and we started building.

Initially, everything felt familiar, easy and seamless

Small services. Clear responsibilities. Independent components.

Exactly what I had enjoyed years earlier.

Then reality arrived.

The customer kept changing requirements.

What looked like a simple change started affecting multiple services. Features that were supposed to be straightforward required coordination across service boundaries.

And things became increasingly complicated.

To make matters worse, we were building a multi-tenant platform.

Different tenants had different expectations, requirements kept evolving, and our architecture was becoming an obstacle rather than an advantage.

The services were individually simple but the system was not.

We spent considerable time going back and forth, fixing issues, coordinating changes, and trying to stabilize the platform.

Eventually, we got things reasonably stable.

But the architectural overhead wasn't going away. Then one day, our senior architect joined a call with me.

We discussed the situation and came to a difficult conclusion.

We needed to make a bold architectural decision: migrate from microservices to a modular monolith.

And we did it, In approximately two weeks, we migrated the architecture. He was amazed how I handled the heavy lifting.

The result?

The team was happy. The work was appreciated. Everyone started smiling again.

But I think the biggest smile was mine. It should be right?😄

Because I knew exactly how much complexity we had just eliminated.

No more running multiple services locally just to work on a feature.

No need to spin up RabbitMQ, Azure Service Bus, and other infrastructure dependencies for routine development.

No unnecessary service-to-service communication.

One deployable application. One database. Clear module boundaries.

Upgrades became easier. Development became simpler.

And continuous delivery became much less painful.

No drama. Just peace.

There's another part of this story worth mentioning.

For years, I had been reading Dr. @mjovanovictech LinkedIn posts and his satureday morning newsletters.

He consistently shared practical ideas about modular monoliths, clean architecture, and making architectural decisions based on real engineering needs.


r/softwarearchitecture • • 15h ago

Discussion/Advice How do you handle long-running transactions spanning multiple components?

27 Upvotes

Since everyone is now using web services, traditional two-phase transactions don't seem to apply anymore. A typical scenario is when you submit a request (e.g. to initiate a payment) and receive a response (e.g. as a webhook) a little while later.

Based on what I've seen in fintech apps, it's usually handled with workers that mark a transaction as pending and then handle the state if it's not consistent.

We have a few posts in r/fintechdev subreddit that discuss transactions in fintech e.g. https://www.reddit.com/r/fintechdev/comments/1epuqxp/do_you_use_saga_pattern_to_handle_multistep/

How do you handle long-running transactions that span multiple components?


r/softwarearchitecture • • 1d ago

Article/Video Designing a 250K Writes/Sec URL Shortener & Distributed ID Generator

Thumbnail youtu.be
5 Upvotes

r/softwarearchitecture • • 1d ago

Tool/Product I built this for AWS architecture diagrams. Curious how others review architecture as they go.

7 Upvotes

I’ve been working on AWS architecture diagrams and keep coming back to this: how can AI help review what you’re building while you’re still drawing and changing things?

You add a service, change a connection. Then you stop and wonder if that even makes sense anymore. Or maybe there’s a simpler way. I wanted to ask those questions right there with the diagram instead of having to explain the whole thing again in a separate chat.

So I built an editor for that. There’s an AI agent that sees what’s on the canvas, can talk through it with you and make changes. It’s AWS specific and uses AWS Well-Architected guidance.

You can draw from scratch, pick a starter diagram or generate one from a prompt. That prompt part still needs work honestly. Even when the architecture makes sense, the complex layouts can get a bit messy. I spend a fair amount of time on that.

What I’m trying to figure out is where this actually helps. And where it gives a confident answer but misses something because it doesn’t have enough context.

Are people doing this already? Asking AI to review as you go and itirate with AI's help? Or do you finish the diagram first and then get feedback, from AI or another person?

Here’s what I built if you want to try it: https://buildplane.ai

The editor is free, no account needed. AI has usage limits because it gets expensive pretty quickly. Still figuring out a reasonable limit there. If you run out of credits while trying it, message me and I’ll reset your limit.

Would appreciate any feedback. Especially if it tells you to do something questionable. That’s useful for me to hear too.


r/softwarearchitecture • • 3d ago

Article/Video My colleagues' Software Architectures course at Carnegie Mellon (17-635) is now free on YouTube

386 Upvotes

Disclosure: Swarnalatha Ashok and Scott Pavetti are my colleagues at CMU, and I help run CS Learn, the program that publishes the recordings.

I wanted to share their course here. 17-635 is a core course in several of Carnegie Mellon's Master of Software Engineering programs. It covers how architectural drivers shape a system's structure, the common styles and patterns, how to document an architecture, and how to evaluate a design against its quality requirements and tradeoffs.

The first three lectures are up now, and a new one will go up each week at the same time. These are the real classroom lectures. The editing is all done by a student team.

Links are in my first comment.


r/softwarearchitecture • • 2d ago

Article/Video LinkedIn Cuts Daily Spark Shuffle Fetch Failures from 750 to 20 with Apache Celeborn

Thumbnail infoq.com
11 Upvotes

LinkedIn has deployed Apache Celeborn as a shared remote shuffle platform across the majority of its Apache Spark and Apache Flink workloads, separating intermediate data storage from compute infrastructure. The deployment reduces daily shuffle fetch failures from approximately 750 to 20, lowers compute costs by 10%, and improves application runtimes by 14%, compared with its previous Magnet implementation.


r/softwarearchitecture • • 2d ago

Article/Video From The Vault: FatCloud Called Itself a Cloud. You Had to Install It

Thumbnail blog.galratner.com
3 Upvotes

r/softwarearchitecture • • 2d ago

Discussion/Advice Anyone integrated with Abanks (Ladonware) or similar core banking system to post payments automatically???

1 Upvotes

I'm not a technical founder or developer but with my consultancy, I got an inbound in the banking industry, so now I’m scoping a small project for a bank: match incoming transfers to loans and post them in their core banking system. Today a person does it by hand, a few hundred payments a month with a spike at month end.

Their core is Abanks, from Ladonware. They tell me it has a documented API and a test environment, but I don’t know yet if it lets you write payments or only read.

Has anyone worked with Abanks or Ladonware specifically? And for people who’ve done something like this with any core...

what went wrong that you didn’t expect?

Duplicates, reversals, audit trail, vendor delays?

What would you ask the vendor before agreeing to anything?

Please, I need perspective and anticipate situations during this implementation, which I will definitely commit to.


r/softwarearchitecture • • 3d ago

Discussion/Advice Is chat really the best DX we can hope for in the age of AI?

30 Upvotes

Hi there! A question for those who regularly use coding agents professionally.

I’ve been developing software for about ten years, including time as a software architect, so I’m probably opinionated about codebase structure.

I still program, just at a higher level of abstraction: I think less about variables and method internals—unless they define a contract—and more in terms of architectural or project-specific concepts. But I still keep the whole picture in my head, control the agent closely, and guide it through small steps. Loosening that control is invariably disappointing. It is the same complex, nonlinear process, compressed into a chat window.

I initially blamed my own bias, but conversations with colleagues and research suggest many professional developers also retain substantial control over design and implementation.

Marketing presents chat as the ideal developer experience. That may suit people who do not want to stay deeply involved, but chat alone seems insufficient for deep human-agent collaboration.

Something feels missing between chat and code changes: a shared object that both human and agent can work on.

Have you felt the same, or does your workflow look different?


r/softwarearchitecture • • 3d ago

Article/Video SysML v2 Lesson 25: State Definitions & Transitions (Actions Unified)

Thumbnail youtu.be
5 Upvotes

Hir/softwarearchitecture,

We are back with Lesson 25 of our technical deep dive into the SysML v2 standard.

In our previous lesson, we connected system parts together using unified flows and messages. But our system components still didn't have operational modes, states, or lifecycles. Today, we look at state machines and state definitions. We will see how SysML v2 dramatically simplifies behavioral modeling by treating a State Definition as a specialized kind of Action Definition, allowing the exact same control patterns we used for actions (first, then, and exhibit) to govern states and transitions.

1. The SysML v1 State Machine Disconnect

In SysML v1 and UML, state machines were governed by a completely separate metamodel from activities. If you wanted to relate a StateMachine to a structural Block, you had to use classifierBehavior or ownedBehavior—an entirely different mechanism than the ActivityPartition swimlanes used for activities. It created disjointed mental models where discrete states felt like a totally different category of thing than continuous actions or processes.

2. The v2 Shift: States Are Actions (And exhibit Works Like perform)

SysML v2 unifies this cleanly:

  • StateDefinition is a kind of ActionDefinition: Because states share the same foundation, they inherit the exact same execution model. A state isn't just a static label; it can execute work during its lifecycle using familiar sub-behaviors (entry, do, and exit actions).
  • exhibit state**:** Just like we used perform action to link a structural part to an action in Lesson 23, SysML v2 uses exhibit state to state that a physical component possesses a given set of operational modes. It is one unified architectural concept with two clean spellings (perform and exhibit).

3. Modeling States, Triggers, and Transitions

Transitions in SysML v2 use the same succession logic (first and then) we learned in Lesson 22, paired with event triggers (accept) and guards to handle discrete mode changes:

Code snippet

package ClimateControlSystem {
    item def StartSignal;
    item def StopSignal;
    
    action def RegulateTemperature;

    state def ClimateControlStates {
        // Initial state specified via 'entry'
        entry;
        then state Idle;
        
        state Idle;
        state Heating {
            // A state can perform actions while active
            do action regulate: RegulateTemperature;
        }
        
        // Transitions triggered by incoming signals/events
        transition from Idle to Heating accept StartSignal;
        transition from Heating to Idle accept StopSignal;
    }
    
    part def ClimateController {
        // 'exhibit state' links the physical hardware to its operational modes
        exhibit state controlModes: ClimateControlStates;
    }
}

4. SysML v1 vs. SysML v2

Modeling ConceptSysML v1SysML v2
State MetaclassDistinct metamodel completely separate from activities.StateDefinition is a specialized kind of ActionDefinition.
Hardware BindingclassifierBehavior or ownedBehavior property on a Block.exhibit state, matching the exact pattern of perform action.
Transition LogicHandled via specialized transition triggers and guard syntax.Unified with first, then, and event accept successions.
Architecture ConsistencySeparate mental models for discrete states vs. continuous flows/actions.Consistent definition-and-usage pattern applied across all behavior types.

Next lesson, we will explore how constraints and validation rules keep these behaviors within safe operational boundaries.

For the software architects here: How do you typically model state machines for complex hardware-software hybrid systems, and do you prefer event-driven state transitions or data-driven mode flags? Let's discuss in the comments!


r/softwarearchitecture • • 3d ago

Discussion/Advice Plato's Sophist and Statesman are basically SWEs modeling sessions

24 Upvotes

He basically just exposes in poetic words a large class hierarchy he already created(probably in his working sessions). He was worried about same questions SWEs were worried just few years ago - how to create a right abstraction, how to create correct subclasses out of one main class (to "cut" class into several subclasses).

It seems to me he also did architectural diagrams (modeling), but we don't have any artifacts of him using UML or something similar.


r/softwarearchitecture • • 4d ago

Tool/Product CodeNib: a wiki and architecture map generated from your repository

Thumbnail gallery
51 Upvotes

CodeNib is an open-source tool that writes a wiki for a repository. The wiki starts from a map: each area of the code is assigned to a node, and arrows show their relations in the code.

Every area has its page. The overview page starts at a public entry point and walks the main call path step by step, and each step has its location in the repo.

Wikis to browse, no account needed:

For your own repository, the CodeNib Wiki GitHub Action is one workflow file. It writes the pages in your CI with a model key you provide, publishes them to GitHub Pages, and stay synced with your code in main.


r/softwarearchitecture • • 3d ago

Tool/Product Updating Architecture

Post image
0 Upvotes

Will soon share in depth


r/softwarearchitecture • • 4d ago

Discussion/Advice Intern with no seniors around, how do I get better at AI-assisted development and actually understand what I'm shipping? Looking for genuine advice.

10 Upvotes

I recently joined a new tech company as an intern after a year-long gap. Before this, I did a 6-month remote front-end internship at a startup, where I handled the entire front-end and one other guy did the back-end. I knew the concepts and basics of front-end languages and frameworks, but I vibe coded pretty much all of it.

Now I'm at a company where everyone is a junior and everyone is figuring things out on their own. There's no senior developer, not even in the whole company, so nobody to tell me what to look at or what to do when something breaks. The framework and even the language are new to me, and I'm still vibe coding with LLMs. The problem is they're non-deterministic. Sometimes they "fix" stuff in the codebase that I never asked them to touch, and I can't always tell whether the change is right.

I'm not trying to give up AI. I want to use it better. My goal is to understand the code and the architecture well enough that when an LLM writes something, I know what's going on and can judge whether it's right. I also want to get good at system design and prompting so I can eventually take a project from start to deployment on my own with AI assisting me. I've heard about agents.md and skills files but have never actually tried them.

My learning style is a bit of a problem. I'm a read-everything, one-shot kind of person, not a step-by-step one, and I forget things quickly, so I often feel dumb. I've watched dozens of talks and interviews on this, but nothing stuck because I always fall back on my old way of learning. I know I should change it, but I'm lazy and don't know where to start.

On the infra side, the team sets up servers manually and has no CI. I ran a homelab before and I'm comfortable with Linux, hosting and deploying, so I could probably help. But I'm new and don't want to step on anyone's toes.

If you're an experienced dev, how would you learn an unfamiliar stack with no mentor, use AI without losing the learning, and maybe bring up CI and deployment as the new intern?

I'd also love to hop on a call with anyone who's up for it, to go deeper. Happy to chat about whatever works for you. Thanks a lot! Resources are appreciated


r/softwarearchitecture • • 4d ago

Discussion/Advice Explicit state machines and AI

18 Upvotes

Hi,

I've been a SWE for 7 years. I mainly did full stack with Java backend applications that are essentially CRUD.

I'm currently experimenting with a kind of fully automated development process via AI agents and found that telling the AI to use explicit state gave very good results whereas without I always had issues like buttons that shouldn't be there. E.g. a delete button that I could press even though I did not even create the entity yet.

I am wondering why I never encountered explicit state machines in my projects. I guess it creates too much overhead and cost for most projects. And for most projects it is not a big deal to just have implicit state machines. But with the emergence of AI coding I have a feeling that explicit state machines should become a standard in any software project. Or am I missing something?

I also feel like they will become the aspect of the code that humans can better review and own in a time where the software becomes more and more like a black box.

Edit:

What I am essentially trying to figure out is, if it will be ever detrimental if I tell AI to do explicit state machines in all of my projects?


r/softwarearchitecture • • 4d ago

Discussion/Advice How do you manage business rules that change more frequently than your application code?

4 Upvotes

A question for software architects:

How do you manage business rules that change more frequently than your application code?

In many systems, pricing, eligibility, validation and approval logic end up scattered across services, buried in conditionals and understood by only a few developers.

Would you rather:

  • Keep them in application code?
  • Use a dedicated rules engine?
  • Manage them through decision tables?

I'm interested in how teams handle testing, versioning and auditing when business rules change.


r/softwarearchitecture • • 4d ago

Tool/Product How do you tell if a SQL warehouse needs a bigger size, more clusters, or just a shorter auto-stop?

3 Upvotes

I've been reading up on SQL warehouse costs, and the pattern I keep seeing is people reaching for a bigger warehouse when the symptom points somewhere else.

The way I'm thinking about it now:

One query is slow or spilling to disk: size

Queries waiting at capacity: max clusters

Warehouse stays awake between short jobs: auto-stop

What surprised me most is that a forgotten setting can cost more than one slow query, because it repeats on every single run.

The auto-stop one is easy to miss. Defaults change depending on how you create the warehouse, and the floor is different in the UI than in the API. One documented bundle deployment skipped auto_stop_mins and ended up at 120 minutes, even though the docs list 10 for Serverless. Nobody touched a query and the bill still moved.

Also curious if people check Power BI DirectQuery before blaming Serverless pricing, since every click can fire another query.

What do you check first when a warehouse bill jumps? And do you set auto_stop_mins explicitly or trust the defaults?

(Most of this comes from a SELECT guide I'm sharing as part of my work at Hackmamba.

Happy to drop the link if anyone wants it.)


r/softwarearchitecture • • 3d ago

Tool/Product How I cut my frontier token costs drastically on long horizon tasks without losing code quality.

Thumbnail dennyvgeorge.substack.com
0 Upvotes

​I ve been testing everything for the past year. frontier APIs, Chinese models, local rigs. And the conclusion is pretty straightforward. There is no perfect model. If someone says there is one, it’s stupidly expensive, and once context bloats over a long horizon task, it degrades anyway. On the flip side, running cheap or local models end-to-end just produces silent architectural rot.

​So my solution at the core is simply division of labor. I dint invent any new technology. It’s just basic systems architecture applied to token economics, separating high-level reasoning from brute-force execution and verification.

The engineering recipe is listed in detail on my paper attached here. U can run the exact same set up as mine using this write up. Hope u guys find it helpful. Cheers.


r/softwarearchitecture • • 4d ago

Tool/Product System designs for newcomers that love the LLM dopamine rush but don’t understand why things are like they are

10 Upvotes

If you're new to engineering and you like LLMs, you've probably had cases where the code looks fine, it runs, but for some reason you don't get it why it works :)

I built something called 'getdeved', a free, hands-on playground for newcomers to learn how real systems work, and what to expect when the time comes.

You can learn concepts such as load balancers, caches, queues, databases, replication, sharding and trade-offs between different approaches. You chase one problem at a time, grow the architecture piece by piece, to understand each concept to detail instead of one and done.

Since you cannot just ignore LLMs, its always good to understand what you want the LLM to build.

I've added 28 topics so far, from scaling to millions of userrs, payments and chat systems. There's also a glossary setup for different terms which you would usually hear on technical meetings and often think what are they talking about :) - here you'd be able to understsand each concept and where does it fit in a problem.

Try it: https://getdeved.github.io

If you try it, I'd love to know if there is something that you don't like or don't understand or just that is confusing.

If you're experienced and see something that doesn't seem correct, feel free to point it out!

It is free forever!

#systemdesign


r/softwarearchitecture • • 4d ago

Article/Video Une application professionnelle conçue pour 20 utilisateurs en compte désormais 200 : quels choix de conception initiaux se sont avérés payants et lesquels ont été contre-productifs ?

4 Upvotes

Une application conçue pour une petite équipe peut fonctionner parfaitement pendant des mois, puis rencontrer des difficultés lorsque plusieurs services l’adoptent simultanément. Le nombre d’utilisateurs n’est pas toujours le seul facteur : les volumes de données, les accès concurrents et les intégrations peuvent changer la donne. Pour une application métier qui passe d’environ 20 à 200 utilisateurs, quels choix initiaux vous ont le plus aidés à absorber la croissance sans devoir tout reconstruire ? Je pense à la séparation des responsabilités, à la gestion des accès, aux tâches asynchrones, aux requêtes en base de données, à la journalisation et à la manière de déployer les nouvelles versions. À l’inverse, quelles décisions prises pour aller vite vous ont coûté cher plus tard ? Je cherche surtout des compromis pragmatiques : comment garder une architecture simple au départ tout en évitant de bloquer les évolutions futures ?


r/softwarearchitecture • • 4d ago

Tool/Product Do teams still need an architecture map as agents write more of the code? We built one, feedback wanted

6 Upvotes

We are building a tool called ProvenMap (my wife and I), so this is a product post. We're looking for feedback.

The idea is: Agents are writing more of the code, and it gets harder to keep the whole system in view. We think teams need org-level architecture knowledge, with its insights and changes, readable in layers.

The tool maps a system from the real sources (code, schemas, APIs, documents).

It does two things mainly:

  • Re-analyses your repos on a schedule. Analysis runs locally. Only derived metadata is pushed.
  • Shows what changed, and compares what is live with a branch.

Once synced, there are three ways in:

  • Chat: people in the org ask it in plain language. A business analyst: "which systems does an order touch?" A CTO: "what changed in checkout this month?"
  • Plugins with MCP: Claude Code, Cursor or other MCP clients read the same map and insights, so agents have the architecture context before they change code.
  • Published boards: a read-only link that opens without an account, for people outside the tool.

We ran it on a few open-source repos. You can open them here: https://provenmap.com/boards

What we would like your feedback on:

  1. Where might this fall short? What blind spots are we missing?
  2. Would you trust an answer from it? What would it have to show you first?
  3. In one year, does a map like this still matter, or do agents just read the code?

Thanks for reading, and for any thoughts.


r/softwarearchitecture • • 4d ago

Discussion/Advice ShadowBox + AI: Build System Design Judgment

Post image
3 Upvotes

I have had the good fortune of sitting in on numerous design reviews, conducting design interviews, and working with brilliant engineers throughout my career. I have learned a lot during this process. One of the most important lessons is developing the art of "engineering judgement".

The engineers I'd call genuinely cracked have a nose for smelling a bad design fairly quickly. Their process is different from others: they notice cues, figure out which constraints are more important than others, realise when common patterns no longer apply, etc.

You can't learn this skill with just diagrams and in an ordinary design review. One technique that has served me well over the years in building good engineering judgement is the "Shadowbox" technique.

A common consensus among engineering circles on X/HN/Reddit is to develop "taste" in software engineering with coding being rapidly automated (or already has, idk) by AI. My strong belief is that the first step in building taste is developing excellent engineering judgement. This is true for senior engineers and junior engineers alike. Even more so for junior ones because they haven't had the experience or opportunity to work on large-scale and complex engineering systems.

With AI becoming more and more accessible with each passing day and models becoming smarter, we can combine it with the Shadowbox technique to become cracked engineers ourselves.

What is the ShadowBox technique?

In this, we take a real situation and divide it into many decision checkpoints. At each checkpoint, we make a decision about the situation and rank the possible actions. We note down the following:

  • the cues or signals
  • assumptions made
  • acceptable failures

Once we do this, we reveal the expert answer corresponding to that checkpoint. From there, we match the cues we made and the cues the expert made.

Then we change one condition and rank again. We keep doing this until we come up with a conditional rule: under condition X, choose approach Y, because the mechanism satisfied requirement Z, and reconsider it when signal W changes.

The original ShadowBox evals showed that just a short training with this technique improved alignment with expert decisions by 28%. But the number is not the point. The point is that you commit before you see the answer. Doing this over and over helps you develop a real mental model. Let's now talk about concrete steps on how we apply this technique in system design.

Step 1 - Start From a Production Case

First, we choose a source about actual architecture design, failures, postmortems, etc. A source can be:

  • an engineering blog explaining a migration
  • an Architecture Design Record (ADR)
  • a DB- or infra-related paper
  • a production postmortem from a real system
  • a conference talk that includes constraints and outcomes

We should not start with something that only mentions "what worked". A real case gives us information about what cues the team saw, what they missed, why they missed that, what happened next, how they make sure this doesn't happen again, etc.

Remember, not every case is a good source. Expert intuition is trustworthy only when the environment has regularities, and the expert has had a chance to learn them. So, I prefer sources where there are many expert voices, disagreements, or proof that the decision was made under conditions someone could actually learn from.

You can add these constraints to your prompt and ask AI to only get sources that follow them.

Step 2 - Ask AI to Keep the Decision Hidden

We can now give a chosen source to AI and ask it to extract the following from it:

  • business/technical context
  • constraints at each checkpoint
  • important decisions
  • credible options
  • what was chosen
  • what happened afterwards

Then, we ask AI to provide only what was known before the first decision and hide everything else from us, including the decision made and the outcome.

For example:

The notification service receives large traffic bursts. One provider has unpredictable latency, duplicate delivery is harmful, and the team has limited operational capacity. Choose how work should move from the API to provider workers.

This is the situation you are dealing with. You don't have the answer yet.

Step 3 - Rank the Options Before Looking At the Answer

At this point, you ask AI to give you three options. For example, three options in the above situation may be:

  1. Call providers synchronously
  2. Store pending work in the database
  3. Use a managed queue

Now, you rank these options as per your understanding and make a note of five things:

  1. Which cues matter
  2. What assumptions you have made
  3. What are your expectations for each option - what it can cause
  4. Which failures are acceptable to you
  5. Your confidence in the ranking

By doing these steps, you have submitted your mental model about the problem. It may not be correct yet, but it's a start.

This is why it is the most important step. If you miss this, you are just reading a paper or going through a case study.

Step 4 - Compare Your Cues With Experts' Cues

This is the point where AI shows us what the engineers chose and why. This is strictly done using the source. Here, we need to compare two things: choices and, most importantly, cues.

Compare along the lines of:

  • Which information did they treat as important?
  • Which information did you overvalue?
  • Which consequence did they anticipate that you missed?
  • Did you reach the same choice through weaker reasoning?
  • Did your different choice fit constraints that weren't there?

Matching the final architecture is barely sufficient. Sometimes we match the final answer with reasoning that would fail in the next case. That's why cues are important: they strengthen your architectural judgement.

I also ask AI to categorise every rationale: is it mentioned in the source, or is it a hypothetical that AI itself generated? At any point, we should not let AI "invent" an expert answer. If an option or rationale is missing from the source, the AI should mark it as inferred.

Step 5 - Change a Cue, and Rank Again

AI now changes one condition. For our notification service example above, it can be:

  • Traffic becomes steady
  • Duplicate delivery is allowed
  • The engineering team knows Kafka well
  • Provider latency becomes predictable
  • Messages must be delivered within two seconds

We now need to rank the options again and explain exactly why the ranking changed. This is important because it identifies the boundary of the decision. For example:

A managed queue is preferable when bursts exceed provider capacity and delayed completion is acceptable. Predictable low traffic may make direct delivery simpler.

By doing this, we are learning when a component actually belongs in a design.

A warning: in real prod systems, cues are usually coupled. Changing traffic can also change failure modes, load, and cost. So, swapping only one cue can make you learn the wrong boundary.

Therefore, sometimes we need to change a group of related constraints and figure out what changed the decision. This is definitely harder, but this is how a real architecture design works.

Step 6 - Failures in a system are good decision points

Failures in a system teach us perhaps the most. Even more than happy paths. Therefore, postmortems of a public outage are gold for building intuition on architecture.

For a postmortem, AI stops just before the incident becomes unavoidable. We then choose what to look into or change. Then, we ask AI to show the next event from the source document.

This is error management training.

We make choices, see consequences, and come up with strategies for unfamiliar cases. This is what we want: identifying the signals for the next incident instead of memorising the one we are studying.

Step 7 - Extract a conditional rule

After each case, write:

Under these conditions, choose this approach, because this mechanism satisfied this requirement. It introduced this cost, and we need to reconsider it when this signal changes.

If you do this for enough problems, you will have a collection of conditional decisions. This is more valuable than a collection of architectural diagrams.

Step 8 - Test the rule on an unrelated system

We can ask AI to give us a different problem with the same constraints. If the first problem was related to notification delivery, a different problem can be related to image processing, payment reconciliation, webhook delivery, etc.

The goal is to build the muscle for recognising a shared structure without being told the topic.

And this is how intuition develops: repeated exposure to identify important cues, the interactions between them, and the limits of a decision.

What AI should and should not be

In this learning technique, AI should be treated as the dumb partner to do the heavy lifting and doing the grunt work. It can be someone who:

  • extracts cases
  • reveals information slowly
  • generates controlled counterfactuals
  • compares your reasoning and the source's reasoning

AI is not the expert, so it should not invent the expert answer. It should be clear when it is certain and when it is guessing. We should treat AI as a scaffold for attention, not an oracle for judgement.

The habit that changed my judgement

I have personally felt a change in my approach after applying this technique. When I come out of an architecture meeting, I have two takeaways: how I defended my design, and the cues I missed.

Defending your design can be the final step, but shadowing real decisions is how we build architectural judgement.

If you genuinely want to become a cracked engineer, you need to stop asking AI to praise or attack your design. You need to ask it to hide the correct answer and make you commit first.

I originally published this on X as well, but included the complete article here so that the discussion can remain on Reddit.