A payments scale-up is six months into replatforming. Four teams, one of them supplied by a nearshore vendor, are moving functionality out of a monolith into services. Every architecture sync ends with the same unresolved question: should merchant onboarding own the merchant record, or should the risk service? Two teams have built against one answer, the vendor team against the other. Nobody has decided, because nobody is sure who is allowed to. The CTO knows the company needs someone to collect these questions and close them, but a permanent architect hire will take two quarters.

So the idea comes up: bring in a solution architect on contract. Someone experienced who will “sort out the architecture” and leave. It sounds sensible, and without two things it ends in disappointment: a list of decisions the architect is expected to close, and a date by which to close them. Without them the architect spends month one drawing the current state, month two writing a target architecture document nobody reads, and in month three the teams still do not know who owns the merchant record.

This article is for CTOs considering a contract solution architect. The thesis is this: the value of such an architect is measured by the number of decisions made and recorded in the first 30 days and by how much knowledge stays in the company after they leave, not by the quality of a target architecture document. If after 30 days there are no recorded decisions, no map of dependencies and no risk register, correct the engagement or end it. Do not extend it in the hope that the architect is “still ramping up”.

Why does a contract solution architect only make sense with an end date and a decision list?

Because architecture is mainly decisions, not drawings. Martin Fowler, quoting Ralph Johnson, describes architecture as “the decisions you wish you could get right early in a project” and as “the shared understanding that the expert developers have of the system design”. Both definitions point the same way: an architect who does not make decisions and does not build shared understanding is not doing the job, however many documents they produce.

A permanent architect has time to settle into the organisation slowly. A contract architect does not, and should not. You pay a day rate higher than for most roles on the team, and the architect’s advantage is coming from outside, free of the history of decisions someone once made and still defends. That advantage fades every month. After half a year the outside architect becomes one more person who “knows how things are” and stops asking the awkward questions.

So build the engagement around two elements. The first is a list of open decisions that are blocking teams, with priorities and deadlines. The second is an end date, or at least a review date after which both sides decide deliberately whether the work should continue. Without these, the engagement turns into an extra person who occasionally gives advice, which is the most expensive possible way to use an architect.

There is a second reason. Deciding to bring in an architect usually signals that something is missing: skills, time or the authority to settle technical disputes between teams. An end date forces an answer to the question of who takes over that function when the architect leaves. If there is no answer, the architect will not solve the problem, only postpone it.

How is a solution architect different from an enterprise architect and a tech lead?

These three roles are often blurred, and the distinction decides who you are actually looking for. Get it wrong and you will hire someone with an excellent CV who does something other than what you need.

An enterprise architect looks at the landscape of systems across the organisation. They deal with the application portfolio, technology standards, which systems are grown and which retired, and how technology supports business strategy. They often work with frameworks such as TOGAF, The Open Group standard now in its 10th edition. Their horizon is years, and their audience is the executive team. We describe the role in more detail in our piece on the agile enterprise architect.

A solution architect works at the level of one solution or programme. They take a specific business problem, such as a new onboarding platform or a partner API, and design the architecture for it: the split into components, the integrations, the high-level data model and how non-functional requirements will be met. They resolve trade-offs between performance, cost, security and time to market, and they make sure the solution fits the existing landscape and any enterprise-level decisions. Their horizon is months, and their audience is the CTO, product owners and the teams. Our glossary entry on the role of the solutions architect covers the scope of the role.

A tech lead is accountable for one team: code quality, engineering practices, delivery pace and people’s growth. They make technical decisions within their team’s boundaries and are often its strongest engineer. Architecture is one of their duties, but they are measured primarily on delivery.

The line between a solution architect and a tech lead runs where a decision crosses a team boundary. One team and one system usually need only a tech lead. When there are several teams, several vendors or a solution that integrates with many systems, boundary decisions need someone who is not also measured on the next sprint. A tech lead under deadline pressure will pick the option that is best for their team this week. A solution architect should pick the option that is best for the whole programme over the next year, even if one team loses out.

There is one more role a solution architect gets confused with: the systems analyst. The analyst specifies what the system must do and how it exchanges data with its surroundings; the architect decides how it is built to do that. The two work closely and overlap on small projects. We covered when you need a business analyst and when a systems analyst in business analyst or systems analyst. An architect does not replace an analyst, and an analyst does not replace an architect, though both are easily overloaded with each other’s work.

When does a company really need an outside solution architect?

Not every architectural problem needs an outside architect. Some situations, though, make it the most sensible move.

Decisions are blocking several teams at once. This is the opening scenario. Teams work in parallel, each has assumed something different about a question that affects all of them, and nobody has the mandate to settle it. The cost grows every sprint, because every assumption accumulates code. An outside architect with a clear mandate can gather these decisions and close them in a few weeks.

The organisation is entering territory it does not know. A first cloud migration, a first event-streaming system, a first integration with a large language model, a first system subject to sector regulation. The team can learn, but learning in production is expensive. An architect who has designed similar solutions shortens the path and avoids mistakes that only show up a year later.

A hard-to-reverse decision is coming. Choosing a platform, a data model, a service decomposition or a cloud provider. Ralph Johnson called architecture “the important stuff, whatever that is”, and important usually means expensive to change. Before such a decision it pays to have someone who knows the consequences from other projects and is not attached to any option.

Your internal architect left or is overloaded. A contract can cover the gap while you hire. There is a trap here: if the contract architect becomes a permanent substitute, the organisation never rebuilds the capability. We explore that dynamic in our piece on why body leasing stops paying off exactly when it starts working.

You need an independent opinion. Before a large investment, before choosing a vendor, or when the team and the board disagree on direction, an outside architect can review and recommend. That is a different kind of engagement, though: short, with a clearly defined deliverable. If that is what you need, see what to expect from a software architecture review.

When is a contract architect a bad idea?

Recognising the situations where an architect will not help, and may even hurt, matters just as much.

The problem is capacity, not decisions. If teams know what to build and how, but there are not enough of them, you need engineers, not an architect. An architect on such a team will start writing code, which is not bad in itself, but you are paying an architect’s rate for an engineer’s work.

Nobody will give the architect a mandate. If decisions will still be made by the board, by a director who “always has a view”, or by a vendor that controls the code, the architect becomes an adviser without influence, writing recommendations nobody implements. That is frustrating for both sides and expensive for the company.

The dispute is political, not technical. Sometimes two directors are arguing about which division owns customer data, and the argument is dressed in architectural language. Melvin Conway observed in 1968, in an article published in Datamation, that an organisation designing a system will produce a design whose structure is a copy of its communication structure. If the organisation’s structure is what is being disputed, an architect will not settle it with a diagram. They can name the issue and show the cost, but the decision belongs to the executive team.

You expect the architect to fix the team. Weak engineering practices, missing tests and chaotic releases are problems an architect can point out but not solve. That job belongs to a tech lead, an engineering manager or a change of process.

You want to outsource thinking permanently. Architecture is knowledge of why a system is built the way it is. If that knowledge lives only in an outsider’s head, every change needs that person. That is not a contract model; it is a dependency on one individual.

Do you need an AI architect, or a solution architect who knows AI?

“AI architect” appears in job ads more and more, and it is worth knowing what it means before you start looking. In practice it covers two different profiles.

The first is a machine learning specialist who designs models, training pipelines, evaluation and MLOps infrastructure. You need this profile if you build your own models or train models on your own data. The second is a solution architect who can embed existing models, for example large language models accessed through an API, into a business system: designing retrieval over documents, access control to data, handling model failures, call costs and monitoring of answer quality. Most companies adopting AI today need the second profile, because the difficulty lies in integration with data, processes and security, not in the model itself.

Such an architect should know the specific risks of systems built on language models. A good reference is the OWASP Top 10 for LLM Applications 2025, which includes prompt injection, sensitive information disclosure, excessive agency, vector and embedding weaknesses and unbounded consumption, among others. Ask a candidate how they would defend a specific system against two of them. The answer quickly shows whether they have experience or just vocabulary.

The second reference is risk management frameworks. NIST published the AI Risk Management Framework 1.0 in January 2023, built around four functions (Govern, Map, Measure, Manage), and a Generative AI Profile (NIST AI 600-1) in July 2024. In the European Union, Regulation (EU) 2024/1689, the AI Act, applies in stages: Chapters I and II, covering prohibited practices and the AI literacy obligation, have applied since 2 February 2025, and the rules for general-purpose AI models since 2 August 2025. If you serve EU users, an AI architect does not need to be a lawyer, but should be able to say which design choices affect how the system is classified and which records and logs must be planned from the start.

The takeaway for a CTO: before you look for an “AI architect”, write down the problem. If it is embedding AI into existing processes, look for a solution architect with documented experience integrating models. If it is building your own models, look for a machine learning specialist and add a solution architect to look after the rest of the system.

How do you write the architect’s mandate before day one?

The mandate is the most important document in the engagement, and it usually does not exist. Without it, the architect decides what to work on, and typically picks what they are best at rather than what you need.

A good mandate fits on one page and answers six questions.

What problem must be solved? Not “tidy up the architecture”, but for example “decide which service owns the merchant record and the onboarding state, and define the integration model with the legacy core so that four teams can work without blocking each other”.

Which decisions does the architect make alone, and which do they recommend? For instance: integration patterns and the split of responsibilities between services are the architect’s call after consulting tech leads; a new platform or vendor is a recommendation to the CTO; budget and scope changes belong to the steering committee.

Who is the audience, and who settles disputes? The architect must know whom to go to when two teams disagree, and that person must have time to resolve the dispute within days, not weeks.

Which deliverables are due, and when? The 30-day list described below, plus an outline of what comes later.

Who is the internal successor? Someone on the team who takes part in the architect’s work from day one and, after the architect leaves, takes over the decision log and the responsibility for upholding it.

When is the review? A date, usually after 30 days, when the CTO and the architect assess what has been done and decide what happens next.

Share the mandate with the teams before the architect arrives. Tech leads need to know that someone is coming who will make decisions affecting their work, and within what limits. Otherwise the architect spends the first week proving they are allowed to ask questions.

What should the architect deliver in the first week?

Week one is about understanding the context, but with a visible output. A good architect does not disappear for a week to “read the documentation”. They talk to people and write down what they hear straight away.

By the end of week one, expect three things.

A system context diagram. One page showing the solution as a whole, its users and the systems it exchanges data with. This is level one of the C4 model created by Simon Brown, whose further levels are containers, components and code. At this stage level one, perhaps level two, is enough. A context diagram is simple, yet different teams surprisingly often draw it differently, and that alone is valuable information.

A list of conversations and findings. In the first week the architect should speak with every team’s tech lead, the product owners, whoever is responsible for infrastructure and security, and the owners of the external systems the solution integrates with. A short note from each conversation, listing problems and assumptions that repeat or contradict each other.

A first version of the open decisions list. Every question teams answer differently or keep postponing because they do not know who decides. At this stage the list may be long and rough. What matters is that it exists and is visible to everyone.

Week one is also a test of the candidate. If after five days the architect has nothing to show beyond system access, treat that as a warning sign. An experienced architect knows that information is gathered in conversations, and project documentation usually describes the state of things from several months ago.

What happens in days 8 to 20: context map, ADRs and decisions to make?

Weeks two and three are the move from understanding to decisions. This is where the architect earns the day rate.

The context map. The concept comes from domain-driven design, described by Eric Evans in his 2003 book. A large system is divided into bounded contexts, each with its own consistent model, and the relationships between them must be made explicit. Martin Fowler notes that it is usually worthwhile to depict those relationships on a context map. In practice the map answers exactly the questions blocking the teams in the opening example: which system is the source of truth for the merchant record, who conforms to whose model, where a translation layer is needed, which dependencies run one way. The map also exposes organisational dependencies, because context boundaries often coincide with team and vendor boundaries, which follows directly from Conway’s law.

The decision log and the first ADRs. The open decisions list from week one is put in order: each decision gets an owner, a deadline, its impact on teams and a note on what knowledge is still missing. The most important decisions are recorded as ADRs, Architecture Decision Records. Michael Nygard proposed the format in 2011: a short document of one or two pages with a title, context (the forces acting on the decision), the decision itself, a status (proposed, accepted, superseded) and consequences, including the negative ones. The collection of ADRs forms the project’s decision log. Its value shows a year later, when a new engineer asks why something was done a certain way and the answer is in the repository rather than in the head of someone who has left.

Non-functional requirements turned into numbers. The architect should collect requirements for performance, availability, security and cost and turn vague statements into measurable targets. “The system must be fast” is not a requirement; “95% of payment status queries under 300 ms at 500 concurrent merchants” is. The adr.github.io initiative calls these architecturally significant requirements: requirements with a measurable effect on a system’s architecture and quality. Without them architecture decisions rest on intuition. Our glossary entry on non-functional requirements explains how to write them.

First resolutions. By day 20 at least some decisions in the log should be made and communicated. Not all of them, because some need a prototype, a load test or a board decision. But the ones that were blocking work and needed no further knowledge should be closed. If after three weeks the architect is still “gathering information” on a question teams have been waiting on for months, something is wrong.

A short weekly decision review with the tech leads is good practice. The architect shows what has been decided, what is in progress and what they need from the teams. That rhythm builds trust faster than any document, because teams see their problems being resolved.

What should be on the table on day 30?

Day 30 is the review point. The CTO should assess concrete deliverables, not impressions. The table below sets out what to expect, how to tell a deliverable is good and which signals should worry you.

Deliverable after 30 daysHow to tell it is goodWarning sign
Context and container diagrams (C4 levels 1–2)Every tech lead recognises their system and agrees on the boundariesOnly the architect knows the diagram; teams have not seen it or dispute it
Context mapFor every pair of systems it is clear who is the source of truth and who conformsArrows without named relationships or data owners
Decision logEvery open decision has an owner, a deadline and a note on missing knowledgeA list without owners that grows but never shrinks
ADRs in your repositorySeveral recorded decisions that teams already apply in codeNo ADRs, or ADRs describing decisions nobody implements
Non-functional requirements with numbersMeasurable targets with a business rationale and a way to measure”High availability” and “good performance” without numbers
Technical risk registerRisks rated for likelihood and impact, each with a proposed actionGeneric risks without actions, or a list identical to a template
Plan for the next 30–60 daysDecisions and work with dates, including planned prototypes and testsA plan to “continue the analysis” with no dates or deliverables
Knowledge handover planA named successor taking part in decisions and a list of final documentsNo successor, or “we’ll hand over at the end”

The table does not mean every item must be complete. A risk register after one month may have a dozen entries, and the context map may show areas marked as unclear. What matters is that the deliverables exist, live in your repository and are used by the teams. A document known only to its author is not an architecture deliverable.

The structure does not have to be invented from scratch. The arc42 template has twelve sections, including context and scope, solution strategy, architecture decisions, quality requirements, and risks and technical debt. The template does not have to be filled in completely, but the architect should work in a structure the successor will recognise.

How can you tell after 30 days that the engagement is not working?

A 30-day review only makes sense if you are prepared to act on it. These signals should prompt a correction or an exit.

No recorded decisions. This is the most important signal. If after a month the architect has not recorded a single decision, there are two possible causes: either the mandate does not let them decide, or they cannot or will not. In the first case, change the mandate. In the second, change the person.

A target architecture document instead of decisions. Some architects produce an extensive document describing the ideal system, often disconnected from what teams can build in the coming months. It can be valuable as a direction, but it does not unblock anyone. If after 30 days you have a beautiful document and teams still do not know who owns the merchant record, the work is heading the wrong way.

Teams route around the architect. If tech leads make decisions without consulting or treat meetings with the architect as a formality, the architect has not built trust. Sometimes that is the person, sometimes the mandate, and sometimes the teams were never told what the role is.

The architect mostly writes code. An architect who codes is valuable, because they understand the consequences of their decisions. But if after a month most of their time goes on implementing backlog features, you are paying an architect’s rate for an engineer’s work while the decisions still wait.

Everything is “under analysis”. Some decisions need time, but if the log shows only items in progress and none closed, the architect is probably avoiding the risk of making a call that might turn out wrong. A good decision today is usually worth more than a perfect one in three months, especially when an ADR records its conditions so it can later be revisited deliberately.

If the engagement runs through a vendor on a staff augmentation basis, know the replacement terms. At ARDURA every engagement starts with a two-week satisfaction guarantee: if the specialist does not meet expectations in the first two weeks, we replace them at no cost, and if a specialist leaves during the engagement, a replacement arrives within five business days. Contracts can be terminated with 30 days’ notice. For an architect, that means the first assessment is worth doing after one week rather than waiting for day 30.

How do you plan the knowledge handover before the architect leaves?

This is where most architecture engagements fail. The architect leaves, and with them the knowledge of why the system looks the way it does. Six months later the team starts questioning decisions whose context it does not know, and reverses some of them, paying a second time.

Handover cannot be a final-week event. It has to be built into the way of working from day one. Four practices make that happen.

A successor from day one. The mandate names an internal person, usually the most experienced tech lead or an engineer with architectural ambitions, who joins every important conversation and co-writes the ADRs. Team Topologies, the model developed by Matthew Skelton and Manuel Pais, describes an enabling team: one that temporarily raises the capabilities of other teams and then moves on. A contract architect should work exactly like that. Success means that after they leave, the successor makes decisions in the same spirit.

Everything in your repository. ADRs, diagrams, the risk register and the context map live in your code repository or wiki, in formats anyone can edit without specialist tools. Diagrams as code, in a text notation that can be versioned, beat files in a tool only the architect has a licence for. A document on the architect’s personal drive is not handed over, even if it was emailed.

Contract terms. The contract should define the scope of final documentation and the rights to it. Under US law, a transfer of copyright ownership is not valid unless it is in writing and signed by the owner of the rights (17 U.S.C. § 204(a)). EU member states have their own rules, and some, Poland among them, require the assignment to be in writing and limited to fields of exploitation the contract lists explicitly. If your contract with a vendor or an independent contractor is silent on this, the architecture documents may not formally belong to you. Check with counsel before signing, not at the end of the engagement.

The final weeks as a reviewer. Towards the end of the contract the architect stops making decisions and starts reviewing the successor’s. That is the best test of handover: if the successor can write an ADR the architect accepts without major changes, the knowledge has transferred. If not, it is better to extend the contract by a few weeks with a clearly defined goal than to leave with the handover unfinished.

The cost of a poor handover is hard to calculate but easy to spot. It shows up as decisions made again, disputes that were already settled and a growing dependence on one person. That is why handover should be one of the criteria for judging the engagement, on a par with the quality of the decisions.

How much does a contract architect cost, and how do you choose one?

ARDURA’s price list has no separate rate for a solution architect. The closest reference point is the Cloud Architect role on our pricing page: EUR 465–650 net per day at senior level and EUR 650–835 net per day at lead level. Over 20 working days, the first month therefore costs roughly EUR 9,300 to 16,700 net. That is simple multiplication, not a quote: the rate for a specific profile depends on technology, industry and scope of responsibility. For other architecture profiles the price list gives no rate.

For comparison, it is worth costing the absence of decisions. If four teams of five or six engineers work on contradictory assumptions and every few sprints end in reworking an integration, the cost of that rework quickly exceeds an architect’s monthly rate. We will not give a single figure, because it depends on your team rates and the scale of rework, but it is a calculation worth doing on your own numbers before talking to the CFO.

How do you choose a candidate? A few questions separate architects from people with the title.

Ask for an ADR they wrote, and for a decision that turned out wrong. An experienced architect has such examples and can explain what they learned. No wrong decisions usually means no decisions.

Give them a short description of your problem and ask what they would ask in week one. Good questions matter more than ready answers. A candidate who immediately proposes a target architecture has not yet understood the problem.

Ask about a trade-off between non-functional requirements. For example, infrastructure cost against availability, or speed of delivery against vendor independence. Frameworks such as AWS Well-Architected, with six pillars (operational excellence, security, reliability, performance efficiency, cost optimisation and sustainability), are useful as a checklist, but the architect should be able to say which pillar loses in your case and why.

Listen to how they talk about handover. If the candidate does not raise it, ask how they end engagements. “I leave documentation” is not enough. You want someone who talks about a successor, reviewing that successor’s decisions and an ADR log.

Availability matters too. At ARDURA, cloud architects join a team within two weeks, and in urgent situations such as an incident or a migration deadline, within 48–72 hours. The profile is described on our page about hiring cloud architects.

What are the key takeaways for a CTO?

A contract solution architect is a good tool in specific situations: when decisions are blocking several teams, when the organisation is entering unknown territory or when a hard-to-reverse decision is approaching. It is not a good tool when engineers are missing, when nobody will grant the architect a mandate or when the dispute is political rather than technical.

Remember seven things. First, distinguish a solution architect from an enterprise architect and a tech lead before you start looking. Second, for an “AI architect”, write down whether you need models built or existing models embedded in your system. Third, write a one-page mandate: problem, decision scope, audience, deliverables, successor and review date. Fourth, expect visible output after the first week: a context diagram, conversation notes and an open decisions list. Fifth, on day 30 judge recorded and applied decisions, not the volume of documents. Sixth, plan the handover from day one and put the rights to documentation in the contract. Seventh, if there are no recorded decisions after 30 days, correct the mandate or change the person rather than extending the engagement.

If you are considering strengthening your team with an architect or another specialist for a defined period, see how staff augmentation with ARDURA works, or book a call. We start with the problem and the decisions waiting to be made, and only then match the profile.