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.
A 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.
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.”
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.
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: security, reliability, 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.
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
During which phase does a Solution Architect primarily focus on defining system requirements and creating high-level design artifacts?
Pre-sales phase
Delivery phase
Post-delivery support phase
Project closure phase
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.