Software architect is 2020's best job. So says job search engine Indeed in its recent survey. The worldwide platform with a database of over 250 million resumes compiled its top-25 list considering salary, growth potential, and employer demand.
The winner leaves behind full-stack developers, data scientists, security specialists, and other sought-after experts from the IT domain. Let’s see why software architects rank so high and what value they bring to companies.
Who is a software architect
There are dozens of definitions for a software or technical architect, but in most general terms a person holding this position drives all critical decisions about the organization of the software system.
This expert defines
- a high-level structure of a software system (architecture), its main components and their interfaces;
- interactions of these components with each other and with external systems; and
- a general architectural vision that guides the organization and serves as a basis for mutual understanding between all parties involved in product development.
Software architects take care of such significant aspects as functionality, performance, resilience, reuse, comprehensibility, scalability, security, technology constraints, and tradeoffs. They also make sure that their decisions are effectively communicated to both stakeholders and technical staff.
How a software architect fits into the organization structure
While the particular function of software architects depend on project size and needs, it’s important to understand how their role differs from that of other key specialists working on the same software solution and towards the same goal — to deliver a successful product.
Software architect vs senior developer
A software architect is often considered a kind of a super-senior developer, which is not quite correct. In fact, the former is a visionary, who designs a blueprint for the solution based on customer requirements and with regard to available technologies. The latter puts the blueprint into practice, applying vast programming knowledge and skills.
Similar to a developer, architects write code but mainly to enforce standards for engineers so that such things as scalability, performance, and security won’t be missed at the initial stage. Besides programming, their activities include a lot of interaction with people.
Software architect vs tech lead
In a standard team hierarchy, a technical lead oversees engineers making sure that they build a product according to the architect’s vision. This individual drives improvements to the teamwork and development process, focusing on tactics. The architect, on the other hand, concentrates on the strategy and bears in mind not only the upcoming release but the whole product.
In smaller companies, however, one person often undertakes both roles, managing a particular release while keeping an eye on the big picture.
Software architect vs product manager
A software architect primarily decides how the solution works internally. A product manager studies external factors like market trends, demand for a particular solution, necessity for improvements, and offerings from competitors. An architect researches existing technical possibilities; a product manager analyzes market opportunities for a new product.
Software architect vs project manager
A software architect and project manager share responsibility for the successful delivery of the solution. But the former is in charge of the code quality and technical risks, while the latter undertakes all the rest — namely, tasks associated with budget, scope, and time frames.
Software architect vs other architects
As the company grows, it must introduce new IT architect roles with a different range of vision and tasks.
A data or information architect defines how to collect, store, integrate, manage, and exchange data across IT systems and applications that use this data in some way.
An enterprise architect supervises technical infrastructures and processes across all units, projects, and departments from the business perspective. This tech leader makes sure that a company's systems architecture supports its strategy and helps in achieving business goals. The enterprise architect usually reports directly to the Chief Technology Officer (CTO) or the Chief Information Officer (CIO).
A solution architect focuses on how a particular software product can address specific business needs. Usually, this position is in demand in specialized areas where tech experts need guidance on industry-specific functionality. The role involves knowledge of business analysis, project management, and systems architecture.
https://www.youtube.com/watch?v=zB9WuYE1REI
“In the case of a large and complex product, there can be several software architects working with separate teams or with separate product lines while a solution architect provides technical governance of the whole project,” Ivan Mosiev, an AWS-certified solution architect at AltexSoft, explains.
A technical or software architect concentrates on a particular project, taking care of its development, implementation, maintenance, support, and evolution. In sum, this specialist supervises all aspects related to software engineering and programming rather than to financial and organizational aspects. Below, we’ll look at the responsibilities of this specialist in more detail.
Software architect responsibilities and duties
There are no pure technical architects — as there is no such thing as an ideal development cycle. Their functions are dictated by numerous factors, from an organization structure to particular business needs. However, we can roughly outline typical duties depending on the engineering stage.
Discovery stage: identifying core needs and offering a high-level solution design
Major responsibilities:
- gathering early non-functional requirements
- evaluating functional requirements captured by a business analyst
- selecting a technology stack and deployment methods
- estimating development time
- designing a high-level architectural solution
A software architect is an inherent part of the discovery team that identifies what a customer wants to build and what resources it will take.
The architect begins with studying high-level functional and non-functional requirements related to performance, security, reliability, and other quality aspects. He or she also considers constraints placed by compliance requirements (like GDPR and CCPA for working with personal data or HIPAA for medical software).
“The first thing to do is to decide if there is a need for custom software or if we can take an existing solution and configure it to meet client needs,” Ivan Mosiev says. In the latter case, an engineering team is able to handle the task without an architect, so this expert won’t participate in the further development process.
The requirements evaluation also answers the question: “Is the idea feasible within reasonable timeframes and on a sensible budget?” “Say, we see that the implementation of the customer’s vision will take hundreds of man-years of development effort. Or a client wants his application to load in a hundredth of a second which is technically impossible,” Ivan Mosiev explains. “Then the architect's task is to manage expectations and offer alternative ways to achieve the client’s business goals.”
Upon evaluation of early requirements, the architect delivers a high-level system diagram describing only the most basic concepts and interactions.
An example of a high-level architectural diagram for an Internet banking system. It shows the big picture of the solution and its relationships with external systems. Source: C4 Model
The architect also selects technical stack and deployment strategies, roughly estimates staff hours and forms a development team. All these decisions are packaged into the final proposal.
Elaboration stage: specifying the requirements and planning the architecture in more detail
Major responsibilities:
- addressing possible risks and constraints
- delivering detailed architectural blueprints
With the proposal approved, the next step is to specify requirements and establish a more detailed architecture that will best solve the problems of stakeholders. In other words, at this stage, architects decide how exactly to build the solution.
When working on the system’s structure, a strong software architect not only maps out the ways to implement the initial idea from the technical perspective, he or she also pinpoints potential constraints and risks related to performance, reliability, usability, supportability, security, and deployment, offering methods to alleviate them. Above all, the architecture should allow for changes and growth. “If scalability is not embedded in the initial design, you will probably waste your money for nothing,” Ivan Mosiev cautions.
To sum up, the elaboration phase is the most significant stage for the architect when important choices influencing the effectiveness and success of the future product are made. At the end of this phase, the architect provides design blueprints with major modules, their interactions, and the most critical low-level components inside them.
Prototype stage: proving the solution viability
Major responsibility:
- building a prototype to prove the project’s viability
The point of this stage is to ensure that the existing development team can actually build the solution using a particular tech stack, and this solution will be capable of handling tasks set by stakeholders. To this end, the architect creates the system’s working skeleton or architectural prototype, which covers the most significant problems and addresses major architectural risks.
If successful, the prototype proves that the architecture is stable, and the project is realistic and feasible. In other words, it makes sense from business and technical points of view to proceed with the next phase.
Construction stage: leading the team through the development process
Major responsibilities:
- further specificating of architecture considering changing requirements
- mentoring tech leads and developers
- writing code examples
- setting quality standards and ensuring adherence to them
- managing changes
At the construction stage, software architects continue to work on designing less significant features and components. They also act as leaders, supervisors, and mentors. Basically, they promote their vision of a project, set quality standards to guarantee consistency across teams, provide code snippets to facilitate the development process, and review the code for compliance with predefined rules.
In case of alterations in requirements and, as a result, in the initial design, the software architect has to take care of changes and prevent their negative effect on expected characteristics — like speed, performance, ability to handle a particular workload, and security.
Transition stage: participating in testing and deployment
Major responsibilities:
- supervising testing and deployment
- managing releases
Software architects participate in the selection of quality assurance (QA) tools and are accountable for continuous integration and deployment. According to Ivan Mosiev, “Working together with the development and testing team, the architect defines how the release will be done.” Among other things, the architect makes decisions on code freezes (periods of time when changes to the code are prohibited), environments and infrastructures to roll out new features, and deployment methods.
Based on the performance testing results, the architect can initiate changes in the infrastructure or project structure. However, if the software was well designed at the initial stages, these alterations won’t lead to time-consuming and costly rebuilding of the system.
Software architect skills and competencies
To successfully perform their duties, software architects need to have a broad and deep technical expertise. So, it comes as no surprise that most of them have grown from senior technical positions. At the same time, an ideal candidate for this role must have an ability to talk not only to machines but to human beings as well. Here’s the list of most important characteristics that make a good software architect.
Examples of software architect career development
Extensive technical background. As a rule, an architect has a Master’s degree in engineering or computing science and a vast portfolio of various projects made with different technologies. The job typically requires 5 to 10 years’ experience in programming.
Coding skills. Software architects can’t lose touch with programming. They write code examples, proofs of concept, and prototypes serving as a basis for developers who further work with these snippets to get them to production. “At times, I entirely write separate modules that are then used and reused in different services,” Ivan Mosiev shares in describing his activities as an architect. It’s worth noting that a software architect codes much more frequently than a solution architect who deals with higher-level concepts and diagrams.
Proved knowledge of cloud technologies. Cloud service providers speed up software development, offering numerous ready-to-use solutions. Not to reinvent the wheel, a software architect must be expert in cloud technologies, knowing what tools to use in each case. This ability can be proved by 3+ years’ experience in working with a particular provider or/ and certification from AWS, Microsoft Azure, or Google Cloud.
Communication skills. The role of the architect involves much communication — with stakeholders, business analysts, and engineers. “Whether it's talking to developers about the benefits of employing a specific pattern, or explaining to management the cost-benefit tradeoffs of buying middleware, communication is core of our success,” the book 97 Things Every Software Architect Should Know asserts. Ivan Mosiev backs up the statement adding “The ability to explain technical thing in simple terms is a must-have if you want to grow from a senior developer or tech lead to architect.”
Leadership. A software architect mentors and coordinates technical teams, promoting their vision of the right solution and standards of quality. To win respect and authority, solid leadership skills are required.
Understanding of the particular business domain. Without domain knowledge, it would be difficult to create an architecture effectively solving business problems. Understanding domain specificity enables the architect to choose the most appropriate approaches and patterns as well as to speak the same language as C-level executives and business representatives, which, in turn, fosters trust.
To hire or not to hire?
When does the need for a software architect arise? “As a rule, architects are employed for big projects where several technical teams — say, frontend, backend, and DevOps — must be coordinated," Ivan Mosiev argues. Another example is a team dealing with a complex and very specific business domain. In this case, an architect will play a crucial role in translating from business language to technical terms and vice versa, all the while solving communication issues.
That said, standard projects like “another Internet shop” or “one more content management system (CMS)” can successfully get along without an architect. Also, this specialist is not required in small teams working on narrow technical problems that are likely to be solved by a senior developer.