ArchitectMind
  1. Home
  2. Tutorials
  3. Book 9 · Cloud, Containers, DevOps & Production Architecture
  4. Volume VIII
  5. Cloud Service Selection
Book 9 · Volume VIII — Cloud Architecture Design, Cost & Migration · Topic 1.2

Cloud Service Selection

Choosing the right cloud service for each need — and defending the choice

11 min readStage 4 · Production & architecture10 interview questions
Chapter
Chapter 1 — Cloud Architecture Design
Prerequisites
Topic 1.1; Volumes I–VII
You will be able to
Evaluate cloud services against explicit criteria, select compute, data, messaging and integration services per workload, validate with proofs of concept, balance a curated platform catalogue with team autonomy, and document selections in ADRs
Covers
Cloud service selection
On this page
  1. 1. Concept / Definition
  2. 2. Why It Exists
  3. 3. Core Concepts — Service Selection
  4. 4. How It Works Internally — Selection Process (ShopNow)
  5. 4A. Deep Dive — Compute Selection
  6. 4B. Deep Dive — Data Store Selection
  7. 4C. Deep Dive — Messaging and Integration
  8. 4D. Deep Dive — Paved Road vs Autonomy
  9. 4E. Deep Dive — Proofs of Concept
  10. 5. APIs / Features / Syntax
  11. 6. Practical Examples
  12. 7. Common Problems & Mistakes
  13. 8. Performance & Production Considerations
  14. 9. Architecture & Design Considerations
  15. 10. Interview Questions & Answers

1Concept / Definition

Cloud service selection is the disciplined process of choosing, for each capability a system needs, the cloud service (or combination) that best satisfies its drivers — functional fit, quality attributes, cost, security, operations and exit options — rather than defaulting to the familiar or the fashionable. With hundreds of services and overlapping options, selection is a core architect skill.

Service evaluation criteria
Figure 1 — Service evaluation criteria
Compute selection path
Figure 2 — Compute selection path
VocabularyMeaning
Paved roadCurated, supported set of services and patterns
Service quotaLimit on usage (adjustable or hard)
PoCProof of concept validating assumptions
Service maturityFeature completeness, stability, ecosystem
Table 1 — Terms

2Why It Exists

Poor selectionConsequence
DynamoDB for complex relational reportingPainful scans, costly GSIs
Aurora for massive key-value at 1M rpsOver-provisioning
Lambda for long-running steady workloadsHigh cost, timeouts
Self-built queues instead of SQSOperational burden
Service unavailable in required regionLate redesign
Table 2 — Why

3Core Concepts — Service Selection

CriterionQuestions
Functional fitDoes it support needed features (transactions, ordering, query patterns)?
LimitsItem sizes, throughput, connections, timeouts, quotas
QualityLatency, availability SLA, durability, multi-AZ/region options
OperationsPatching, scaling, backups — who does what?
CostPricing dimensions vs our workload profile
Security & complianceEncryption, IAM, audit, certifications, residency
EcosystemSDKs (Java), IaC, observability integration
SkillsTeam experience, hiring market
ExitData export, open protocols, alternatives
Table 3 — Criteria

4How It Works Internally — Selection Process (ShopNow)

StepDetail
1. Characterise workloadTraffic shape, data model, access patterns, state, latency, volume growth
2. ShortlistFrom platform catalogue first; new services allowed with justification
3. EvaluateScored matrix against weighted criteria
4. PoC / benchmarkValidate critical assumptions (latency, limits, cost)
5. Decide + ADRRecord drivers, options, rationale, exit
6. Platform onboardingIaC module, observability, security defaults, runbooks
Table 4 — Process

4ADeep Dive — Compute Selection

WorkloadRecommendedWhy
Steady microservices, many teamsEKS (or ECS)Density, ecosystem, portability
Spiky event handlers, glueLambdaPay per use, no capacity
Simple web/API with low opsApp Runner / ECS FargateMinimal platform
Licensed software, OS controlEC2Control
Batch, HPCAWS Batch (Spot)Cost
Long workflowsStep Functions + servicesOrchestration
Table 5 — Compute choices

4BDeep Dive — Data Store Selection

Data store selection
Figure 3 — Data store selection
Access pattern questionLeads to
Need joins, transactions, ad-hoc queries?Aurora PostgreSQL
Known key-based access at massive scale?DynamoDB
Sub-ms reads of hot data?ElastiCache/Valkey or DAX
Full-text, relevance?OpenSearch
Analytical scans on large data?Redshift, Athena on S3
Graph relationships?Neptune
Time series?Timestream
Table 6 — Pattern → store

4CDeep Dive — Messaging and Integration

NeedService
Work queue, decouplingSQS
Fan-out notificationsSNS
Event bus with routing rules, SaaS eventsEventBridge
High-throughput ordered streams, replay, Kafka ecosystemMSK
Stream processingManaged Flink / Kinesis
Workflow orchestrationStep Functions
API front doorAPI Gateway / ALB + gateway
Table 7 — Integration choices

4DDeep Dive — Paved Road vs Autonomy

ApproachProsCons
Strict catalogueConsistency, supportabilitySlower innovation
Free choiceInnovationSprawl, security gaps, ops burden
ShopNow modelPaved road (~35 services) + "trail" process: new service needs ADR, security review, owner, IaC moduleBalance
Table 8 — Governed flexibility

4EDeep Dive — Proofs of Concept

PoC goalExample
Latency at scaleDynamoDB conditional writes at 50k tps: p99 8 ms
LimitsMSK partition count per broker at target throughput
CostLambda vs Fargate at projected traffic
IntegrationJava SDK, IAM auth, observability
Failure behaviourFailover timing with JDBC wrapper
Table 9 — Validate assumptions, not features lists

5APIs / Features / Syntax

YAML
# Weighted evaluation matrix (architecture repo) — search engine selection
criteria: { fit: 0.25, ops: 0.20, cost: 0.20,
            performance: 0.15, security: 0.10, exit: 0.10 }
options:
  opensearch-service:    { fit: 4, ops: 4, cost: 3, performance: 4, security: 5, exit: 4 }
  opensearch-serverless: { fit: 3, ops: 5, cost: 4, performance: 3, security: 5, exit: 4 }
  self-managed-es:       { fit: 5, ops: 2, cost: 3, performance: 4, security: 3, exit: 5 }
result: { opensearch-service: 3.90, opensearch-serverless: 3.90, self-managed-es: 3.55 }
decision: opensearch-service   # tie broken by need for custom plugins (ADR-074)
JAVA
// PoC harness: measure DynamoDB conditional-write latency with the Java SDK v2
var latencies = new ConcurrentLinkedQueue<Long>();
try (var exec = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 200_000; i++) {
        exec.submit(() -> {
            long t = System.nanoTime();
            try { ddb.updateItem(reserve(randomSku(), 1)); }
            catch (ConditionalCheckFailedException ignored) { }
            latencies.add((System.nanoTime() - t) / 1_000);
        });
    }
}
System.out.println("p99 µs = " + percentile(latencies, 99));
HCL
# Paved-road module usage: new services get secure defaults and observability
module "orders_queue" {
  source = "git::https://github.com/shopnow/tf-modules//sqs-standard?ref=v2.3.0"
  name               = "order-notifications"
  owner              = "team-orders"
  max_receive_count  = 5
  alarm_on_dlq       = true
}

6Practical Examples

6.1 Wrong store corrected

A team used DynamoDB for seller reporting and spent heavily on scans and GSIs. Moving reporting to Athena on S3 (fed by DynamoDB exports) cut cost 70% and simplified queries.

6.2 PoC changed the decision

A team assumed Lambda would be cheapest for a new pricing API; the PoC showed steady 2,000 rps traffic made EKS on Graviton 3× cheaper.

6.3 Region availability check

PayGrid's EU plan needed a service not yet available in a target region; selection criteria caught it before design finalisation.

6.4 Worked example — workload profile

AttributePricing API
TrafficSteady 2k rps, 3× peaks
Latencyp99 < 50 ms
StateStateless + Redis
ChoiceEKS
Table 10 — Profile first

6.5 Worked example — limits review

ServiceLimit checked
SQSMessage 256 KB, FIFO throughput
Lambda15 min, concurrency
DynamoDB400 KB item, partition throughput
Table 11 — Limits early

6.6 Worked example — ecosystem check

NeedCheck
Java SDK v2, OTel instrumentation, Terraform providerAll available
Table 12 — Integration fit

6.7 Worked example — interview whiteboard

PromptAnswer outline
"How do you choose between AWS services for a new system?""Characterise workloads (traffic shape, access patterns, state, latency, scale). Evaluate candidates against weighted criteria: fit, limits/quotas, quality (latency, SLA, multi-AZ/region), operational model, cost at our scale, security/compliance/residency, ecosystem (Java SDK, IaC, observability), skills, exit. Prefer paved-road services; PoC critical assumptions; record ADR; onboard with IaC modules and defaults. Typical mappings: EKS for steady services, Lambda for spiky events, Aurora for relational, DynamoDB for key-value at scale, SQS/SNS/EventBridge/MSK by integration needs."
Table 13 — Structured answer

6.8 Worked example — NovaBank selection constraint

ConstraintEffect
Services must support in-country regions and RBI auditSome services excluded until available in ap-south-2
Table 14 — Regulatory filter

6.9 Worked example — anti-patterns

Anti-patternEffect
Resume-driven selectionComplexity without need
Ignoring limitsLate redesign
No PoC for critical pathsSurprises in production
Sprawl of similar servicesOps burden
Table 15 — Common mistakes

6.10 Worked example — two stores together

PatternExample
Aurora (orders) + DynamoDB (carts) + OpenSearch (search)Polyglot persistence by need
Table 16 — Multiple fits

6.11 Worked example — cost at scale

ServiceLow volumeHigh volume
API GatewayCheapCostly vs ALB
Table 17 — Re-evaluate as scale grows

6.12 Worked example — service maturity

SignalCheck
GA status, feature parity, regional coverage, community useAvoid preview in tier-0
Table 18 — Maturity risk

6.13 Worked example — trail process

Requirement for new serviceDetail
ADR, security review, owner, IaC module, runbookBefore production
Table 19 — Governed adoption

6.14 Worked example — observability integration

ServiceTelemetry
MSK, Aurora, DynamoDBCloudWatch metrics → AMP
Table 20 — Must be observable

6.15 Worked example — exit assessment

ServiceExit path
DynamoDBExport to S3; repository abstraction
Table 21 — Plan exits

6.16 Worked example — interview follow-ups

Follow-upAnswer
"Lambda or containers?"Depends on traffic shape, duration and cost at scale — PoC
"How limit sprawl?"Paved road with trail process
Table 22 — Common probes

6.17 Worked example — checklist

Item✔
Workload profiled✔
Criteria scored✔
Limits checked✔
PoC for critical assumptions✔
ADR✔
Platform onboarding✔
Table 23 — Selection baseline

6.18 Worked example — AI/ML services

NeedOption
LLM featuresAmazon Bedrock (managed models, data controls)
Table 24 — Newer domains follow the same criteria

6.19 Worked example — identity selection

NeedOption
Customer identityCognito or specialised CIAM SaaS (feature fit)
Table 25 — Build vs buy overlap (1.4)

6.20 Worked example — re-selection triggers

TriggerAction
Cost growth, new service, limits hitRe-evaluate
Table 26 — Selections aren't permanent

6.21 Worked example — interview scenario

QuestionAnswer
"Team wants MongoDB on EC2"Compare DocumentDB/DynamoDB; require ops ownership; ADR
Table 27 — Challenge constructively

6.22 Worked example — catalogue size

MetricShopNow
Paved-road services35
Services with exceptions6
Table 28 — Healthy balance

6.23 Worked example — selection record fields

FieldExample
CapabilityOrder notifications queue
DriversAt-least-once, 5k msg/s, DLQ
ChosenSQS standard
RejectedMSK (overkill), EventBridge (routing not needed)
Table 29 — Concise selection record

6.24 Worked example — benchmark results table

Candidatep99Monthly cost at target
DynamoDB8 ms₹5.6 L
Aurora (row locks)41 ms₹7.9 L
Redis Lua3 ms₹4.1 L (durability concerns)
Table 30 — Evidence for the ADR

6.25 Worked example — regional service matrix

Serviceaps1aps2mec1
MSK Replicator✔✔✔
Aurora DSQLCheckCheckCheck
Table 31 — Verify per region

6.26 Worked example — selection anti-bias

PracticeDetail
At least three options incl. "do nothing/simplest"Avoid anchoring
Table 32 — Better decisions

7Common Problems & Mistakes

MistakeFix
Familiarity biasCriteria
Late limits discoveryEarly review
Unvalidated assumptionsPoC
SprawlPaved road
Table 33 — Mistakes and fixes

Selection mistakes are mostly cognitive rather than technical. Familiarity bias picks the service the team used last time, and resume-driven choices add complex services nobody needs; a written set of weighted criteria and at least three options, including the simplest, counters both. Limits are discovered late, after design, when a 256 KB message size, a 400 KB item size or a 15-minute timeout forces rework, so review limits during shortlisting. Critical assumptions about latency or cost go untested until production; run a time-boxed proof of concept for anything on the critical path. Finally, without governance, teams adopt overlapping services for the same job, multiplying operational and security burden; a paved road with an exception process keeps the estate manageable.

8Performance & Production Considerations

ConsiderationPractice
QuotasMonitor
Cost driftRe-evaluate
Service changesRoadmap tracking
Table 34 — Operating selections

A selection decision has to be operated after it is made. Monitor service quotas and usage against limits, with alarms well before thresholds, and request increases ahead of peak events, because some quotas take days to raise and others are hard limits. Track cost per service and per unit of business volume, so drift towards a pricing crossover is visible early. Follow provider roadmaps and announcements: new services, regional launches or deprecations can change the best answer, and preview features should stay out of tier-0 paths until they are generally available. Check that every selected service is integrated into observability, with its metrics flowing to the shared monitoring stack. Set explicit re-selection triggers and revisit decisions when they fire.

9Architecture & Design Considerations

GuidelineDetail
Workload-drivenProfiles
Evidence-basedPoCs
Governed flexibilityPaved road + trail
Table 35 — Design guidance

10Interview Questions & Answers

Q1BasicConcept

What is cloud service selection?

Cloud service selection is the disciplined process of choosing, for each capability a system needs, the cloud service or combination of services that best satisfies its drivers, rather than defaulting to what the team knows or what is fashionable. AWS alone offers several ways to run compute, store data and move messages, each with different limits, pricing dimensions and operational models. Selection starts from the workload's characteristics, such as traffic shape, access patterns, state, latency and growth, then evaluates candidates against weighted criteria, validates critical assumptions with proofs of concept, and records the decision and exit path in an ADR. Done well, it prevents expensive redesigns once the system is in production.

Q2BasicConcept

Name key criteria.

Functional fit comes first: does the service support the features you need, such as transactions, ordering or your query patterns? Then limits and quotas, including item sizes, throughput, connections and timeouts, because hard limits force redesigns. Quality covers latency, availability SLA, durability and multi-AZ or multi-region options. The operational model asks who patches, scales and backs it up. Cost means the pricing dimensions applied to your workload profile at expected scale. Security and compliance cover encryption, IAM, audit, certifications and data residency. Ecosystem means the Java SDK, IaC provider and observability integration. Skills means team experience and hiring. Exit means data export, open protocols and alternatives. Weight these per decision.

Q3IntermediateTrade-off

When would you pick DynamoDB over Aurora?

Pick DynamoDB when access patterns are known in advance and key-based, scale is very large or very spiky, and you need predictable single-digit-millisecond latency without managing capacity or connections. Shopping carts, sessions, inventory reservations and idempotency records fit well: you design the table and keys around the queries, and the service scales almost without limit. Choose Aurora PostgreSQL when you need joins, multi-row transactions, ad-hoc queries, reporting or a data model that will keep evolving. The classic mistake is using DynamoDB for complex relational reporting, which leads to expensive scans and secondary indexes; ShopNow moved such reporting to Athena on S3 and cut its cost by 70%. Many systems use both.

Q4IntermediateTrade-off

When would you pick Lambda over EKS?

Pick Lambda when work is event-driven, short-lived and spiky, with low steady utilisation: S3 upload processing, queue consumers with bursty traffic, webhook fan-out, scheduled glue and small APIs with modest traffic. You pay per invocation, scale to zero and manage no capacity. Choose EKS when traffic is steady and high, latency must be consistently low, processes run for a long time, or you already run many services on a shared platform with a service mesh and common tooling. Cost often decides it. ShopNow assumed Lambda would be cheapest for a new pricing API, but a proof of concept showed that steady 2,000 requests per second made EKS on Graviton three times cheaper.

Q5Senior EngineerConcept

Why run a PoC?

Because the decisions that hurt most rest on assumptions that documentation and feature lists cannot confirm. A proof of concept validates the critical ones with your own workload, data and code: latency at target load, such as DynamoDB conditional writes at 50,000 per second with a p99 of 8 milliseconds; limits, like MSK partitions per broker at the planned throughput; cost at projected traffic, for instance Lambda against Fargate; integration with the Java SDK, IAM authentication and observability; and failure behaviour, such as failover time through the JDBC wrapper. Keep it narrow and time-boxed, with pass criteria agreed before starting. The results become evidence in the ADR and sometimes reverse the expected choice.

Q6Senior EngineerTrade-off

How do you choose among SQS, SNS, EventBridge and MSK?

Match the service to the interaction pattern. SQS is a work queue: point-to-point decoupling, buffering and retries with dead-letter queues, where each message is handled by one consumer. SNS is pub/sub fan-out, pushing each message to many subscribers such as SQS queues, Lambda functions or HTTP endpoints. EventBridge is an event bus with content-based routing rules, schema discovery, archive and replay, and native integration with AWS and SaaS event sources. MSK is managed Kafka, for high-throughput streams ordered per partition key, long retention, replay by consumer groups and the Kafka ecosystem, at the cost of more operations. Avoid overkill: ShopNow rejected MSK for a simple notification queue and chose SQS.

Q7Technical ArchitectConcept

What is a paved road?

A paved road is a curated, supported catalogue of services and patterns that teams can use with minimal friction, because the platform team has already done the hard work. Each service on it comes with IaC modules containing secure defaults, observability integration, runbooks, cost tagging and support, so a team creating an SQS queue gets encryption, a dead-letter queue and alarms automatically. It is the easy path, not the only path. The benefits are consistency, faster delivery, a smaller security surface and less operational sprawl; the risk is slowing innovation if it becomes rigid. ShopNow's paved road holds about 35 services, with six exceptions approved through its trail process.

Q8Technical ArchitectDesign

How do you add a service outside the paved road?

Through a lightweight but explicit trail process, rather than either free choice or a blanket ban. The team writes an ADR explaining the need, which paved-road options were considered and why they do not fit, the evaluation results and the exit plan. A security review covers IAM, encryption, data classification and compliance. Before production, the service gets a named owning team that will operate it, an IaC module with secure defaults and tagging, observability integration and runbooks. If the service proves widely useful, the platform team may adopt it into the paved road. This leaves teams room to innovate while keeping every new service supportable, secure and visible to the organisation.

Q9Solution ArchitectTrade-off

How does scale change selection?

Pricing models favour different services at different volumes, so the best choice at launch may be the wrong one at ten times the traffic. Per-request pricing, as with Lambda and API Gateway, is cheap at low volume and expensive under high, steady load, where provisioned capacity on EKS or an ALB costs far less. DynamoDB on-demand suits unpredictable traffic, while provisioned capacity with autoscaling is cheaper for steady patterns. Scale also reaches limits, such as partition throughput, connection counts or account quotas. So model cost at current, expected and peak volume during selection, identify the crossover points, and set re-selection triggers such as cost growth or limits being approached.

Q10Solution ArchitectDesign

Why assess exit at selection time?

Because lock-in is cheapest to reduce before data, integrations and team habits are built around a service. At selection time you can prefer open protocols or compatible APIs, such as PostgreSQL-compatible Aurora or Kafka-compatible MSK, put repository or adapter layers around proprietary APIs, and confirm that data can be exported in usable formats, for example DynamoDB export to S3. Two years later the same change costs a migration project. Assessing exit does not mean avoiding managed services; it means knowing the cost and path of leaving and accepting lock-in deliberately where the benefit is worth it. Record the exit path in the ADR and test the export at least once.

Newsletter

Get new tutorials every week

New ArchitectMind tutorials and interview questions, once a week. No spam, unsubscribe anytime.

Almost done! Check your inbox and click the confirmation link to complete your subscription.
Keep going in Book 9

Cloud, Containers, DevOps & Production Architecture

Volume I · Topic 1.1

What Is Cloud Computing?

Cloud Computing & Cloud Architecture Fundamentals

Volume I · Topic 1.2

Cloud Service Models

Cloud Computing & Cloud Architecture Fundamentals

Volume I · Topic 1.3

Cloud Deployment Models

Cloud Computing & Cloud Architecture Fundamentals

Volume II · Topic 1.1

Regions

AWS & Cloud Services

Volume II · Topic 1.2

Availability Zones

AWS & Cloud Services

Volume II · Topic 1.3

Edge Locations

AWS & Cloud Services

Volume III · Topic 1.1

Containers

Containers & Kubernetes

Volume III · Topic 1.2

Containers vs Virtual Machines

Containers & Kubernetes

Volume III · Topic 1.3

Container Lifecycle

Containers & Kubernetes

Volume IV · Topic 1.1

IaC Fundamentals

Infrastructure as Code & Platform Engineering

Volume IV · Topic 1.2

Declarative vs Imperative

Infrastructure as Code & Platform Engineering

Volume IV · Topic 1.3

Immutable Infrastructure

Infrastructure as Code & Platform Engineering

Volume V · Topic 1.1

DevOps

CI/CD & DevOps Architecture

Volume V · Topic 1.2

Development + Operations

CI/CD & DevOps Architecture

Volume V · Topic 1.3

Continuous Integration

CI/CD & DevOps Architecture

Volume VI · Topic 1.1

Production Readiness Review

Production Architecture & Reliability Engineering

Volume VI · Topic 1.2

Operational Requirements

Production Architecture & Reliability Engineering

Volume VI · Topic 1.3

Capacity

Production Architecture & Reliability Engineering

Volume VII · Topic 1.1

Cloud-Native Principles

Cloud-Native Architecture & Multi-Region Systems

Volume VII · Topic 1.2

Twelve-Factor Applications

Cloud-Native Architecture & Multi-Region Systems

Volume VII · Topic 1.3

Immutable Infrastructure

Cloud-Native Architecture & Multi-Region Systems

Volume VIII · Topic 1.1

Architecture Drivers

Cloud Architecture Design, Cost & Migration

Volume VIII · Topic 1.3

Managed vs Self-Managed

Cloud Architecture Design, Cost & Migration