For a capstone project, choose EC2 for a server that must run continuously and needs full OS control. Choose Lambda when your app reacts to discrete events and finishes in minutes. Choose Fargate when you have a container and want AWS to run it without you managing servers. The right answer depends on how your project behaves, not on which service you already know.
Checked against the official AWS documentation and the SAA-C03 exam guide on 8 September 2026.
Three ways to run code on AWS, in plain terms
Amazon EC2 gives you resizable, secure compute capacity as virtual servers. It offers more than 1,000 instance types across Intel, AMD and Arm processors. You choose the instance, install the software, and stay responsible for scaling, patching and securing it.
AWS Lambda is described by AWS as serverless compute that runs code "at any scale with zero infrastructure management". You supply a function. AWS runs it when an event occurs, and you pay per use. A function can run for up to 900 seconds (15 minutes). The default timeout is 3 seconds, and you can raise it in 1-second increments.
AWS Fargate is a serverless, pay-as-you-go compute engine. You use it with Amazon ECS or Amazon EKS to run containers. The ECS developer guide notes that Fargate removes the need to choose server types or plan cluster scaling. You supply a container image, and AWS runs it.
AWS's own decision framework
AWS publishes a compute decision guide. It frames the choice around workload type, performance, scalability, management overhead and cost. It also covers latency, compliance, integration, reliability and development experience. The guide groups EC2 as scalable compute for CPU-intensive workloads. It groups containers around a goal of letting teams "focus on building applications rather than the runtime environment". It groups serverless services, including Lambda and Fargate, around minimising your management overhead.
On management overhead, the guide is direct. Running EC2 instances means you take on setup, scaling, patching and securing the servers yourself. Lambda runs code in response to events without you managing any server. Container services sit in between: the guide calls them "a middle ground between control and convenience". That single line is a fair summary of the whole decision.
Compute options compared
Use this table to check your project against each service before you commit to one.
| Factor | EC2 | Lambda | Fargate |
|---|---|---|---|
| Management overhead | You patch, scale and secure the server | AWS runs the code, with no server to manage | AWS runs the container, with no server or cluster to manage |
| Scaling model | You choose the instance type and scaling rules | Scales automatically with each event | Scales the task without you selecting server types |
| Execution-time ceiling | Runs continuously, with no built-in limit | 900 seconds (15 minutes) maximum per invocation | Not subject to Lambda's function timeout |
| Billing unit | On-Demand, Savings Plans or Spot Instances, by the instance | Per request plus per GB-second of compute used | Per second, with a 1-minute minimum for Linux and a 5-minute minimum for Windows |
| Best-fit capstone project | An always-on app or database server you need full control over | An event-driven task, such as processing an uploaded file | A containerised API or microservice you do not want to patch |
Sources for the EC2 rows are the EC2 product page and the AWS compute decision guide. The execution ceiling comes from the Lambda timeout documentation. The billing unit for Fargate comes from the Fargate pricing page.
A decision you can apply today
Answer one question about your capstone project. Does it need to keep running whether or not anyone is using it right now? Or does it only need to do work when something specific happens?
If it runs continuously and needs OS control or specific software, pick EC2. If it responds to a discrete event, such as an upload or a schedule, and finishes in a few minutes, pick Lambda. Check that your work fits inside the 15-minute ceiling first. If it is already packaged as a container and you want to avoid patching a cluster, pick Fargate.
Worked capstone scenarios
An always-on web app with a database fits EC2 or Fargate. EC2 suits it if you need specific software on the host or control over the operating system. Fargate suits it if the app is already containerised and you would rather not patch a server for it.
An event-driven image or file processor fits Lambda. AWS names event-driven applications and real-time data processing among its stated Lambda use cases. The Lambda free tier includes 1 million requests and 400,000 GB-seconds of compute a month. The 900-second timeout leaves room for realistic file sizes, provided you test with your largest expected input.
A containerised microservice API fits Fargate. It bills per second, with a 1-minute minimum for Linux tasks. Each task includes 20 GB of ephemeral storage, so a small API with light local storage needs no separate volume. AWS's own pricing page gives two separate examples, not the same task on two operating systems. Five Linux tasks on x86, at 1 vCPU and 2 GB memory for 10 minutes a day, come to about $1.26 a month. Ten Windows tasks at the same 1 vCPU and 2 GB memory, running 1 hour a day, come to about $47.25 a month. The Windows example also runs a larger workload than the Linux example. Treat the two figures as separate reference points, not a clean OS cost comparison.
Where this fits the SAA-C03 exam
Compute selection is not one of the four scored SAA-C03 domains. Per the official exam guide, those domains are Design Secure Architectures (30%), Design Resilient Architectures (26%), Design High-Performing Architectures (24%) and Design Cost-Optimized Architectures (20%). Compute choice instead runs through several tasks inside those domains, which is why it keeps reappearing.
Task 2.1, "Design scalable and loosely coupled architectures", names "serverless technologies and patterns (for example, AWS Fargate, AWS Lambda)". It also asks candidates to determine when to use containers and when to use serverless patterns. Task 3.2, "Design high-performing and elastic compute solutions", names AWS Batch, Amazon EMR and Fargate. It covers container orchestration through Amazon ECS and Amazon EKS. It also covers choosing the right EC2 instance type or Lambda memory setting. Task 4.2 is titled "Design cost-optimized compute solutions". These tasks sit inside the two highest-weighted domains after Security. That placement is why a capstone-level compute decision is worth getting right before the exam, not just before the project.
How Ethnus builds this into the course
The Ethnus AWS Solutions Architect Associate course syllabus lists an "Introduction to Compute" topic naming EC2 and Lambda, under its AWS Foundational Services section. Both services you are most likely to reach for first are named directly in the curriculum. The published syllabus does not name Fargate, ECS, EKS or containers. Anything on those services in this article comes from AWS's own documentation, not a claim about course content.
The course lists more than 150 hours of AWS architecting content and more than 250 hours of foundational essentials content. Lab and sandbox access is described as offering step-by-step walkthroughs and unlimited attempts, alongside trainer-led sessions for doubt clearing. If you want structured, trainer-led practice with EC2 and Lambda before you design the compute layer for your capstone project, that is a specific next step.
Common mistakes to avoid
Do not default to EC2 out of familiarity when your workload is purely event-driven. An idle EC2 instance still bills for the time it runs. An equivalent Lambda function only charges when it executes.
Do not assume Lambda fits every workload regardless of duration. A batch job that often needs more than 15 minutes will not finish inside one Lambda invocation. Check your realistic processing time against that ceiling early.
Do not forget that Fargate still bills for the vCPU and memory you reserve. It bills for that even if the task sits partly idle. Right-size the task definition instead of over-provisioning it by default.
Frequently asked questions
Can I use more than one of these services in the same capstone project?
Yes. Many architectures combine them, such as an EC2 or Fargate-hosted API that calls a Lambda function for one event-driven step. Choose per component, not per project.
Does Lambda's 15-minute limit include time waiting on a database or another service?
The 900-second maximum covers the whole invocation. Time spent waiting on a slow dependency counts against it. Check the timeout documentation and test with realistic response times.
Is Fargate always more expensive than running my own EC2 instance?
Not necessarily. Fargate bills per second for the vCPU and memory you select, per the Fargate pricing page. EC2 has its own On-Demand, Savings Plans and Spot pricing. Compare your actual task size and run time against an equivalent instance before deciding.
Does the SAA-C03 exam expect me to have used Fargate hands-on?
The exam guide lists Fargate inside the knowledge and skill statements of Task 2.1 and Task 3.2. You are expected to know when to use it, per the official exam guide. AWS recommends at least a year of hands-on experience with AWS services generally, though this is guidance, not a strict requirement to sit the exam.
Work through the EC2-versus-Lambda decision on your own capstone idea this week. Then check each new AWS service you meet against three questions. Does it run continuously? Does it react to an event? Does it need a container? For guided practice with EC2 and Lambda before your project design review, start with the Ethnus AWS Solutions Architect Associate course.
