Three Skills That Separate Architects From Senior Devs
- YT :: https://www.youtube.com/watch?v=EsB401dN5b4
- Original title :: The 3 Skills That Separate Architects From Senior Developers
Architecture is not a promotion for being the strongest coder - it is a different job. A senior dev delivers a clean solution to a problem; an architect defines the constraints everyone else builds inside. Karell breaks the gap into three skills: systemic thinking (trade-off accounting), organizational influence (translating technical direction into cost/risk/value), and structural design plus a technical vision that includes the migration path.
Systemic thinking is trade-off accounting
A senior dev sees the local fix; an architect asks what happens to the whole system after that fix lands. The microservices trap is the canonical example: scaling does get easier, but nobody priced what was bought with it - recovery time going from 15 to 90 minutes, 40% of user operations now needing cross-service calls, 18 months of engineering time spent. That is not "microservices bad", that is failing to price the trade-off.
The question shifts from "is this better technically?" to "better for what?" - better for scaling, deployment, hiring, debugging, or for the team that gets paged when the diagram meets production.
Organizational influence
Senior devs talk mostly to engineers. Architects have to reach product, operations, other architects, and executives, explaining one technical direction in terms of cost, risk, value, and engineering reality.
The budget example: current infrastructure costs $3M/year with 8 FTE; the cloud-native replacement costs $4.2M/year with 5.5 FTE. That is a $1.2M cost increase, but it frees 2.5 engineer-years worth roughly $1M in productivity. A senior dev argues the architecture is technically better; an architect makes the business case - not because the technical case stopped mattering, but because it is not sufficient. Being right without anyone understanding cost, risk, and value means being right in a corner.
Structural design and technical vision
A senior dev fixes coupling; an architect changes the conditions that created it. In a company growing from 10 to 80 engineers with no architectural guidance, the result is a big ball of mud where every team touches every other team's code. The senior dev fixes the worst coupling points - useful, necessary, still local. The architect maps the domain, identifies bounded contexts, defines ownership, establishes communication patterns, creates a migration path, and stops the mess from recoupling two sprints later. Structure is only valuable when it reduces future chaos.
Technical vision answers three questions: where are we now, where do we need to be in two to three years, and how do we get there without stopping the business. A target diagram alone is wall art. Netflix's microservices migration took seven years, and before migrating they built Hystrix, Eureka, and Zuul - the vision included prerequisites (circuit breakers, service discovery, API gateway) and the migration path as part of the architecture. People want the destination without the road, then act shocked when the team lands in a ditch.
The practical rule
Stop trying to prove you are a stronger senior dev; change your output instead. Before proposing a solution, write down the trade-offs. Before arguing with another team, translate the point into cost, risk, and value. Before fixing the same coupling for the fifth time, ask what structure keeps recreating it.
Accept the part that feels like a loss: the primary artifact becomes decisions, documents, alignment, and influence rather than code. Code is concrete - it runs or it blows up honestly - while architecture is people, trade-offs, meetings, and ambiguity. Architects who stay too close to the code create conflict with the engineers they are meant to enable; the job is not being the final boss of pull requests, it is making better technical decisions easier for everyone else. If you still measure your value mainly by what you personally ship, you may be a very strong senior dev - but you are probably not doing architecture yet.