Cloud Engineering Course
Scalable FastAPI Applications on AWS
Design, test-drive and deploy a production quant pricing & risk API on AWS — the cloud-native, scalable architecture behind a modern quant library.
Enrol now
- Lifetime access — all lessons & updates
- 26 lessons across 2 structured parts
- Fully worked Jupyter notebooks
- Market datasets + published benchmark prices
- Free lesson previews before you buy
- 14-day money-back guarantee
Secured by a no-questions-asked 14-day refund.
Overview
Introduction
Most FastAPI material stops at a single file and a uvicorn command. This course goes the whole distance: you design, test, containerise and deploy a quant pricing & risk API to AWS exactly the way a real engineering team does.
The service you build mirrors QuantIndex itself — a cloud-based, high-performing, scalable, AI-assisted and test-driven quant pricing and risk library, exposed as an API. You learn the architecture by building it.
It is a workflow course as much as a tooling course: test-driven development to keep pricing code trustworthy, infrastructure as code so environments are reproducible, and continuous deployment to shorten the loop between writing code and running it in production.
Hands-on
The project you'll build
You build one service end to end: a FastAPI application that values instruments and returns risk numbers. You start with repository structure and a tested application skeleton, then add validated pricing endpoints backed by the quant logic.
From there you containerise the service, provision AWS infrastructure with Terraform — VPC, ECR, ECS Fargate — and ship a first deployment behind a custom domain and HTTPS.
Part 2 makes it production-grade: a PostgreSQL database on RDS with migrations, a Redis cache for curves and results, async pricing jobs, end-to-end tests, monitoring and error tracking, autoscaling under load, a CI/CD pipeline, and AI-assisted endpoints.
Outcomes
What you'll learn
Production FastAPI
Structure a FastAPI service with routers, Pydantic models and services that scales past one file.
Test-driven delivery
Write endpoints test-first with pytest and FastAPI's TestClient, enforced by quality gates.
Containerisation
Package the service in Docker with small, reproducible, production-ready images.
Infrastructure as Code
Provision AWS VPC, ECR and ECS Fargate with Terraform — no clicking in the console.
Cloud deployment
Deploy behind HTTPS on a custom domain, then iterate safely with feature flags.
Data & caching
Add AWS RDS PostgreSQL with migrations and a Redis cache for curves and results.
Scale & observability
Autoscale under load and wire up monitoring, logging and error tracking.
Continuous deployment
Build a CI/CD pipeline that lints, tests and ships every change automatically.
Stack
Tools & technology
The course teaches a workflow, not just a toolset — here is what we use and what you could swap in.
| Tool | Used for | Alternatives |
|---|---|---|
| FastAPI | The async API framework for the service | Flask, Django, Litestar |
| pytest | Test-driven development and the test suite | unittest, nose2 |
| Docker | Containerising the service for any environment | Podman, Buildah |
| Terraform | Provisioning AWS infrastructure as code | AWS CDK, CloudFormation, Pulumi |
| AWS ECS Fargate | Running the container without managing servers | EKS, App Runner, Kubernetes |
| AWS RDS & ElastiCache | Managed PostgreSQL database and Redis cache | self-hosted Postgres/Redis, Aurora |
| GitHub Actions | The CI/CD pipeline | GitLab CI, CircleCI |
Syllabus
Course curriculum
26 lessons across 2 parts. Lessons marked Free preview can be read before you enrol.
Part 1 — Foundations & Cloud InfrastructureFrom an empty repository to a tested service running live on AWS.
- 1.Introduction & what you'll buildThe architecture of a scalable quant pricing API and why FastAPI, TDD and AWS.Free preview
- 2.Project setup & repository structureLay out the repository, dependencies and tooling for a service that will grow.
- 3.The FastAPI application skeletonBuild the app structure and your first validated pricing endpoint.Free preview
- 4.Tests, TDD & code qualityTest endpoints test-first with pytest, plus linting and type checks.Free preview
- 5.Pydantic models for pricing & riskModel requests and responses with validated, well-documented schemas.
- 6.Building the pricing & risk endpointsWire the quant logic behind clean, versioned API endpoints.
- 7.Configuration & secrets managementLoad settings from the environment and handle secrets safely.
- 8.Containerising the service with DockerBuild small, reproducible, production-ready container images.
- 9.Infrastructure as Code with TerraformDescribe your AWS infrastructure as version-controlled code.
- 10.AWS networking: the VPCBuild the network the service runs in — subnets, routing and security groups.
- 11.Container registry: AWS ECRPush and version your container images in a private registry.
- 12.Orchestration: AWS ECS FargateRun the container as a managed, serverless service.
- 13.Deployment, domain & HTTPSShip the first live deployment behind a custom domain and TLS.
Part 2 — Data, Scale & DeliveryMaking the service production-grade: data, caching, scale, observability and CI/CD.
- 1.Persistence: AWS RDS for PostgreSQLAdd a managed relational database to the service.
- 2.Database integration with SQLAlchemyConnect FastAPI to PostgreSQL with async sessions.
- 3.Database migrations with AlembicEvolve the schema safely and reproducibly.
- 4.Caching curves & results with RedisCache expensive curve builds and pricing results in ElastiCache.
- 5.Async pricing jobs & background workersOffload heavy batch pricing to background workers.
- 6.End-to-end testsTest the deployed service against real infrastructure.
- 7.Packaging the quant libraryPublish the pricing logic as a reusable internal Python package.
- 8.Feature flags for safe rolloutShip and toggle new models without redeploying.
- 9.Monitoring, logging & error trackingSee what the service is doing and get alerted when it breaks.
- 10.Autoscaling & load testingScale the service with demand and prove it under load.
- 11.CI/CD: continuous deploymentLint, test and ship every change automatically.
- 12.AI-assisted pricing & research endpointsAdd AI-assisted endpoints on top of the pricing core.
- 13.Conclusion, hardening & next stepsProduction hardening, cost control and where to take the service next.
Before you start
Prerequisites
- Comfortable with Python — functions, classes, virtual environments.
- Basic web concepts: HTTP methods, status codes, JSON.
- Git fundamentals (clone, branch, commit, push).
- An AWS account — the course uses small, low-cost resources and shows how to clean them up.
Fit
Who this course is for
Quant developers
You write pricing code and want to ship it as a reliable, scalable service.
Backend engineers
You know Python and want production FastAPI and AWS deployment patterns.
Data & platform teams
You support quants and want a reproducible, test-driven delivery pipeline.
Engineers entering finance
You want a realistic, cloud-native quant project to build and show.
Faculty
Your instructor
QuantIndex Faculty
QuantIndex Faculty are practising quantitative analysts and platform engineers who build and operate cloud-native pricing services. This course is written and reviewed by the team behind QuantIndex's own scalable pricing and risk API.
Benchmarked & verified
Every price you compute is checked against published results from leading textbooks and market data. You do not finish the course hoping your model is right — you finish it knowing.
Questions
Frequently asked questions
Do I need prior AWS experience?
No. The course introduces each AWS service as it is used and shows the Terraform that provisions it. You do need an AWS account.
Will this cost much on AWS?
The course uses small, low-cost resources and shows you how to tear everything down. Expect only a few dollars if you clean up as instructed.
Is it really a quant course or an engineering course?
Both. The project is a quant pricing & risk API, so the examples are pricing endpoints — but the focus is the engineering: testing, infrastructure, scale and delivery.
Does every lesson include code?
Yes. Each lesson pairs the theory with working Python you can run locally before deploying.
What do I receive?
Twenty-six lessons across two parts, the full source for the service, the Terraform, and the CI/CD configuration.
Is there a refund policy?
Yes — a 14-day, no-questions-asked money-back guarantee.
Ready to start?
- Lifetime access — all lessons & updates
- 26 lessons across 2 structured parts
- Fully worked Jupyter notebooks
- Market datasets + published benchmark prices
- Free lesson previews before you buy
- 14-day money-back guarantee
Secured by a no-questions-asked 14-day refund.