Skip to content
What Makes a Great Software Architect? 10 Core Skills Explained
R&D Management 18 min read

What Makes a Great Software Architect? 10 Core Skills Explained

This article breaks down the software architect role into three architecture levels, nine daily activities, and ten essential skills—including design patterns, decision-making frameworks, simplification principles, and hands-on coding—with references to GoF patterns, enterprise integration patterns, ThoughtWorks Tech Radar, and TOGAF.

Architect's Guide
Architect's Guide
Architect's Guide

The article opens by referencing a GitHub project by senior architect Justin Miller that gained 3.8K stars, then draws on the author's own experience to define the software architect role and outline a path to mastery.

Definitions

Software Architect (Wikipedia): a software expert who makes high‑level design decisions and sets technical standards (coding standards, tools, platforms). The chief expert is the chief architect.

Software Architecture (Wikipedia): the fundamental organization of a system embodied in its components, their relationships to each other and the environment, and the principles governing its design and evolution.

Three Architecture Levels

The author prefers a three‑level model:

Application level – lowest, detailed, single‑application focus; communication within one dev team.

Solution level – middle, covers one or more applications that satisfy a business need; mixes high‑ and low‑level design; involves multiple teams.

Enterprise level – highest, spans multiple solutions; abstract, requires refinement by lower‑level architects; involves cross‑organization communication. Reference: https://github.com/justinamiller/EnterpriseArchitecture.

Architect as Glue

Architects connect three dimensions:

Horizontal – between business units and developers or across dev teams.

Vertical – between management and developers.

Technical – integrating disparate technologies or applications.

Nine Core Daily Activities

Define required development technologies and platforms.

Define development standards (coding, tools, review process, testing methods).

Support identification and understanding of business requirements.

Design systems and make decisions based on requirements.

Document architecture definitions, designs, and decisions.

Review architecture and code for adherence to patterns and standards.

Collaborate with other departments and architects.

Mentor and consult developers.

Refine high‑level designs into lower‑level designs.

Note: Architecture design is continuous, especially in agile development; these activities repeat iteratively.

Ten Essential Skills

1. Design

Know fundamental design patterns – GoF's Design Patterns: Elements of Reusable Object‑Oriented Software is mandatory reading; patterns like MVC remain foundational for newer patterns (e.g., MVVM).

Study patterns and anti‑patterns deeper – For integration, Gregor Hohpe's Enterprise Integration Patterns applies from legacy file exchange to modern microservices.

Understand quality attributes – Maintainability, reliability, adaptability, security, testability, scalability, availability; good architecture satisfies non‑functional requirements. See Wikipedia on quality attributes.

Try and understand different tech stacks – Hands‑on experience with diverse stacks (e.g., SAP R/3 vs. JavaScript) builds breadth and depth; curiosity matters more than mastering everything. Free openSAP courses are suggested.

Analyze application patterns in frameworks – e.g., Observables in Angular; understand why and how they are applied, and read framework source code.

Stay curious, watch the user community .

2. Decision‑Making

Separate important from trivial using conceptual integrity (stick to a chosen concept for clarity and maintainability) and consistency (apply conventions uniformly).

Prioritize – Critical decisions must be made early; a "bad" decision is better than no decision when blockers exist. Use Weighted Shortest Job First (WSJF), widely used in agile; time‑criticality and risk reduction are key weighting factors.

Know your authority – Don't decide outside your scope; clarify roles with peers. Lower‑level architects propose to higher‑level architects, not decide. Review important decisions jointly.

Evaluate multiple options – Always list alternatives; compare via defined metrics (license cost, maturity) rather than intuition. This yields sustainable decisions and eases cross‑department adoption.

3. Simplification

Apply Occam's Razor: if a solution rests on many assumptions, it's likely wrong and overly complex. Reduce assumptions.

View solutions from multiple angles – top‑down vs. bottom‑up, left‑to‑right vs. right‑to‑left data flow. Ask: "In a perfect world, what would change?" or "How would Company X/Person Y do it?"

Step back – After long discussions, pause and reassess from a macro view; refactor at the abstraction level. Sleeping on it often yields simpler solutions.

Divide and conquer – Break large problems into smaller ones, solve and validate each, then re‑evaluate the whole.

Refactoring isn't bad – If no simpler path exists, improve a complex solution later. Prerequisites: sufficient automated tests and stakeholder buy‑in. Reference: Martin Fowler's Refactoring: Improving the Design of Existing Code .

4. Programming

Even enterprise architects must understand developers' daily work; otherwise developers won't trust you and you won't grasp their challenges.

Run side projects – To try new tech/tools and experience developers' emotions (frustration, joy). Experience = observation + feeling + hypothesis (Schneider, Experience and Knowledge Management in Software Engineering ). Long‑term use yields better hypotheses for daily decisions.

Only try what matters – Use a structured radar. ThoughtWorks Technology Radar classifies items as Adopt (strongly recommended), Trial (try in low‑risk projects), Assess (explore impact), Hold (proceed with caution). This helps prioritize learning.

5. Documentation

Some docs are critical (architecture decisions, coding guidelines); others can be generated.

Clean code is the best documentation – Ability to judge code quality is essential. Reference: Robert C. Martin's Clean Code .

Generate docs when possible – Systems change fast; manual updates lag. Model‑driven APIs can auto‑generate docs from definition files or source code. Tools: Swagger, RAML.

Document only what's necessary, as concisely as possible – Focus on one thing per doc; put extras in appendices. Decision records should tell a persuasive story, not dump arguments. Audit past docs: "Is all necessary info included? What can be omitted? Is there a red line?"

Learn architecture frameworks – TOGAF, Zachman provide structural "tools" for systematic architecture work beyond documentation.

Reference link:

https://github.com/justinamiller/SoftwareArchitect
Original Source

Signed-in readers can open the original source through BestHub's protected redirect.

Sign in to view source
Republication Notice

This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactadmin@besthub.devand we will review it promptly.

design patternssoftware architecturesystem designdecision makingtechnical leadershipenterprise architecturesoftware architectarchitecture skills
Reader feedback

How this landed with the community

Sign in to like

Rate this article

Was this worth your time?

Sign in to rate
Discussion

0 Comments

Thoughtful readers leave field notes, pushback, and hard-won operational detail here.