Solutions architect tasks explained from pre sales to delivery

Solutions architect tasks explained from pre sales to delivery

This blog explains that solutions architect tasks center on making the right decisions across pre-sales and delivery by balancing business goals, technical constraints, and risk.

6 mins read
Apr 02, 2026
Share
editor-page-cover

Solution Architect (SA) is the person who owns “does this solution actually work for this customer and this business?” in the messy middle between product promises and production reality. If you’re picturing someone who only draws boxes and arrows, you’re missing the punchline: an SA is accountable for outcomes, not diagrams. The diagrams just happen to be one of our favorite ways to argue politely.

The role often splits into pre-sales (shape a viable solution, win the deal) and delivery (make it real, reduce risk during implementation). Some organizations combine these; others have separate pre-sales SAs and delivery architects. Maturity matters a lot: in a startup you might write Terraform at 2 a.m.; in a large enterprise you might spend that same 2 a.m. negotiating who owns the firewall rule.

The core loop is consistent across environments: discover constraints and goals, design a solution that fits, and de-risk the plan early with prototypes, estimates, and decision records.

End-to-end Solution Architect workflow from pre-sales discovery to delivery handoff, with key decision gates and iteration.
End-to-end Solution Architect workflow from pre-sales discovery to delivery handoff, with key decision gates and iteration.

That workflow diagram is the “happy path.” In practice, you’ll loop back whenever you hit a gate like “security says no,” “budget changed,” or “latency target is unrealistic.”

Cover
Master AWS Certified Solutions Architect Associate SAA-C03 Exam

AWS is a popular cloud service provider that offers various services. The course prepares you to design secure, resilient, high-performing, and cost-optimized architectures. You’ll learn about services to secure your AWS resources and accounts against external threats. You’ll also cover various load balancing and replication techniques to make AWS applications highly available and resilient against failover. Next, you’ll cover several storage options and analytics tools that help design high-performing architectures. You’ll also cover various cost optimization techniques by choosing appropriate purchasing opinions for compute and storage solutions. Finally, you’ll gauge your understanding with the help of some practice exams. You’ll also get hands-on experience deploying AWS resources using Cloud Labs. This course covers all four domains for the SAA-C03 exam and increases your chances of becoming an AWS Certified Solutions Architect Associate.

30hrs
Intermediate
63 Cloud Labs
51 Exercises

Day-to-day cadence#

Your day is usually a triage exercise: you time-block deep work, then protect it like it’s production data. Expect a rhythm of customer calls (requirements, demos, technical deep dives), internal syncs (sales, product, engineering, security), and focused solo time for designs and docs.

Two habits separate calm SAs from frazzled ones: keep a lightweight risk log (what could break, probability, impact, owner, next action) and track key decisions with short decision records (what we decided, why, alternatives, date). This prevents “we never agreed to that” from becoming a recurring weekly meeting.

When you’re building SA muscles around cloud choices and operational constraints, structured practice on cloud architecture helps and is a solid way to pressure-test your instincts around cost, reliability, and tradeoffs without relying on vendor-specific magic.

With the daily rhythm in mind, it helps to zoom out and see how the same SA muscles get used differently in pre-sales versus delivery.

Phase

Task category

Typical tasks (day-to-day)

Key stakeholders & typical time allocation

Pre-sales

Tech

Discovery & requirements framing; high-level architecture (HLA) & solution options; scope/assumptions/risks; estimates & sizing; PoC approach & success criteria; security/compliance early checks

Stakeholders: Sales/Account Exec, Prospect sponsor, Product owner, IT/Engineering leads, Security, Procurement. Time: ~40–70% pre-sales (varies by pipeline intensity)

Pre-sales

Comms

Run workshops; translate business goals → technical narrative; write/review RFP/RFI responses; present solution & trade-offs; align pricing/SOW inputs; manage expectations & decision timeline

Stakeholders: Sales leadership, Customer decision makers, Legal/Procurement, Partner teams (if any). Time: included in pre-sales allocation (often 20–35% of total week when active deals)

Delivery

Tech

Detailed architecture (LLD); backlog/epics decomposition; integration/API design; performance/resilience planning; security threat modeling; environment/release strategy; design reviews & governance; troubleshoot escalations

Stakeholders: Customer engineering, Internal dev/DevOps, QA, Security, Data/Analytics, Operations/SRE. Time: ~60–90% delivery (during implementation)

Delivery

Comms

Kickoff & alignment; stakeholder updates/status; change control & scope negotiation; risk/issue management; documentation handoff; training/enablement; post-go-live retrospectives

Stakeholders: Project/Program manager, Customer PM/Delivery lead, Support/Operations, Executive sponsor. Time: included in delivery allocation (often 15–30% of total week)

Pre-sales responsibilities#

Pre-sales is where you earn the right to build. Your job is to qualify whether the opportunity is real, winnable, and deliverable. I usually start by pinning down success criteria in plain language: what outcome the customer will measure, what “done” means, and what would cause them to say “no.” Then we surface constraints early: budget ceilings, compliance boundaries, current-stack realities, and delivery timelines.

Next comes architecture sketching, but it is intentionally lightweight. You’re comparing options, not producing a blueprint. A solid pre-sales whiteboard usually includes two to three viable architectures, the trade-offs that matter to this customer, and the assumptions you are making.

Estimation is the tricky bit. You’re not just sizing effort, you’re bounding uncertainty. I like to separate “must-have scope” from “nice-to-have,” call out integration unknowns, and offer phased delivery that maps value to time. When risk is high, de-risk on purpose: run a small proof of concept to test one assumption, not to build the final product.

Tip: Pre-sales is where vague language sneaks in. If you hear “real-time,” “secure,” or “simple,” ask for a number, a standard, or an example.

Delivery responsibilities#

Delivery is where we convert intent into execution. The SA role shifts from “options and persuasion” to “decisions and follow-through.” Your first responsibility is translating the agreed design into an executable plan: milestones, dependencies, interfaces, and a backlog that engineering can actually pick up. If pre-sales produced a narrative, delivery produces a map.

Day-to-day, you guide implementation without stealing the keyboard. You unblock teams by clarifying requirements, answering edge-case questions, and keeping a running list of decisions. You also protect the system’s quality attributes: securityreliability, performance, and cost. These are rarely solved once. They are maintained through reviews, guardrails, and steady attention.

Change control is the hidden job. Scope will move, timelines will slip, and new stakeholders will appear. You help everyone make explicit trade-offs, ideally with written decisions. When two “reasonable” paths conflict, your value is being the person who can say, “Here’s the risk, here’s the cost, here’s what we gain,” and get alignment.

Important: Delivery SAs fail quietly when they skip governance. A lightweight decision log and a regular risk review prevent “surprise architecture” in week eight.

Stakeholder interaction map#

Stakeholders are not just names on an org chart. They’re moving forces with different incentives. On the customer side, execs want outcomes and risk reduction, product wants scope and speed, and ops wants stability. Internally, sales wants a clear story, engineering wants clarity and autonomy, and legal wants fewer surprises.

The SA sits in the middle, which sounds glamorous until you realize you’re basically an interpreter. Your best tool is predictable touchpoints: when escalations happen, who is consulted, and which decisions require sign-off. Conflict zones are normal: sales versus engineering on timelines, product versus ops on reliability, security versus everyone on “just ship it.” The alignment tactic is to move arguments from opinions to artifacts: acceptance criteria, SLOs, decision records, and phased plans.

Solution Architect's stakeholder map: key touchpoints and escalation paths
Solution Architect's stakeholder map: key touchpoints and escalation paths

Deliverables checklist#

Deliverables are how you scale yourself. They let new people join midstream and still understand why the system looks the way it does. The key is to keep artifacts small, updated, and owned.

Artifact / Deliverable

Purpose (what “done” looks like)

Owner (primary)

Phase created → Update cadence

Discovery brief / problem statement

Align on goals, constraints, success criteria, assumptions

Solution Architect (SA)

Discovery → Update as scope changes

Stakeholder map + RACI

Clarify decision makers, approvers, contributors, comms paths

SA

Discovery → Review per phase / org changes

Requirements (functional + non-functional)

Captures “must-have” behaviors + NFR targets (latency, security, compliance)

SA + Product/BA

Discovery → Update each iteration/release

Current-state architecture / context diagram

Document baseline systems, integrations, pain points

SA

Discovery → Update when landscape changes

Target-state vision / roadmap

Describe end-state architecture and migration path

SA

Discovery/Pre-sales → Quarterly or major pivot

High-Level Design (HLD)

Defines architecture, key components, flows, major tradeoffs

SA

Solutioning → Update per milestone

Low-Level Design (LLD)

Specifies detailed component behavior, interfaces, configs

SA + Tech Leads

Delivery → Update per change request

Architecture Decision Records (ADRs)

Record decisions, options considered, rationale, consequences

SA

Solutioning/Delivery → Per decision (continuous)

Threat model

Identify attack surfaces, mitigations, security requirements

SA + Security

Solutioning → Revisit per major change

Data model (conceptual/logical)

Define entities, relationships, ownership, retention

SA + Data/Engineering

Solutioning → Update per schema change

API contracts / interface specs

Lock integration contracts (endpoints, schemas, SLAs)

SA + Engineering

Delivery → Versioned per release

Integration sequence diagrams

Make system interactions unambiguous for build/test

SA

Delivery → Update per interface change

Capacity estimate + scaling strategy

Validate workload assumptions and scaling approach

SA + SRE/Platform

Solutioning → Recheck before launch, then quarterly

Cost estimate / TCO model

Provide forecast cost drivers, guardrails, optimization levers

SA

Pre-sales/Solutioning → Monthly during build; quarterly after

Implementation plan (milestones)

Convert design into deliverable plan (workstreams, dependencies)

SA + PM

Pre-sales/Delivery

Risk register

Track technical/project risks with mitigations and owners

SA + PM

Discovery → Weekly/biweekly

Test strategy (incl. NFR tests)

Ensure coverage for performance, resiliency, security, DR

QA Lead + SA

Delivery → Per release

Migration plan (data/app)

Define cutover steps, rollback, validation, comms

SA + Engineering

Delivery

Observability plan

Define logs/metrics/traces, dashboards, alerting approach

SA + SRE

Delivery → Per release

SLI/SLO definitions

Set measurable reliability targets and error budgets

SRE + SA

Delivery/Operate → Quarterly

Runbooks / operational playbooks

Provide step-by-step procedures for common ops scenarios

SRE/Operations

Delivery → Update after incidents/changes

Incident response plan

Define severity levels, escalation paths, comms templates

SRE/Operations + SA

Delivery/Operate → Semiannual drills; after changes

DR/BCP plan

Define RTO/RPO, failover steps, testing schedule

SRE + SA

Delivery → Test at least annually; after major change

Release plan + change log

Coordinate deployment windows, approvals, rollback notes

Release/DevOps + SA

Delivery → Each release

Architecture review checklist (governance)

Ensure design meets standards (security, resiliency, cost)

SA

Pre-sales/Delivery → Each major review gate

Handover / knowledge transfer pack

Enable support/ops and delivery teams to operate confidently

SA

Late delivery → At go-live; refresh per major release

A few that consistently pay for themselves: a high-level design for shared context, a low-level design for implementation clarity, and architecture decision records so “why” doesn’t evaporate after the meeting ends. On the ops side, runbooks plus SLIs and SLOs turn reliability from a vibe into something measurable. The cadence matters: a beautiful document that never gets updated is just expensive fiction.

Note: Every artifact should answer “who uses this” and “what decision does it unlock.” If it unlocks nothing, it is probably overhead.

Metrics, KPIs, tools#

SAs get measured indirectly, which can be frustrating. In pre-sales, you’ll feel it through win rate, cycle time, and whether what was promised matches what was delivered. Adoption metrics and customer satisfaction (NPS, renewal signals, referenceability) often reflect how realistic your early framing was.

In delivery, watch defect leakage and rework. If teams keep rebuilding the same component or revisiting fundamental choices, your decision process is too implicit. Architecture-facing metrics are more concrete: SLO attainment, incident frequency, latency percentiles, and cost trends. The win is not “zero incidents.” It’s fewer surprises and faster recovery.

Tooling is intentionally boring. Diagrams, docs, a backlog, and a decision log. Use whatever your org standardizes, but be consistent. The most valuable “tool” is a shared language for risk and trade-offs. When everyone can say, “This increases blast radius,” you’re already ahead.

Test Your Understanding: Solution Architect Roles and Responsibilities

1.

During which phase does a Solution Architect primarily focus on defining system requirements and creating high-level design artifacts?

A.

Pre-sales phase

B.

Delivery phase

C.

Post-delivery support phase

D.

Project closure phase


1 / 3

Pitfalls and 30-60-90 plan#

Common pitfalls are surprisingly human. Overdesigning is a classic: you build a cathedral when the customer needed a cabin. The twin is vague scope: “integrate with X” without defining the data, the workflow, or the failure modes. Two anti-patterns I see often are the hero SA (everything routes through you) and the no-ADR culture (decisions happen, but no one can prove they happened).

For a 30-60-90 plan, start with listening. In the first 30 days, learn the domain, read past postmortems, map stakeholders, and identify where decisions currently get lost. By 60 days, standardize a minimal set of artifacts, establish a risk log, and introduce a predictable review cadence. By 90 days, tie architecture to measurable outcomes: SLOs, cost targets, delivery milestones, and a clear escalation path.

Tip: If you’re unsure what to do next, improve one feedback loop: incidents, customer objections, or delivery delays. Fixing the loop fixes the system.

Final words#

A Solution Architect’s core value is clarity and risk reduction, delivered through good decisions and good communication. In pre-sales, you focus on fit, constraints, a credible story, and estimates that acknowledge uncertainty. In delivery, you focus on execution, governance, non-functional requirements, and explicit trade-offs. Keep your artifacts lightweight but alive, manage stakeholders with predictable touchpoints, and measure outcomes with KPIs that reflect both delivery health and system quality.


Written By:
Zarish Khalid