Learner Baseline

Who this course is for, what it assumes, and what it deliberately does not assume.

1. The target learner

A backend/software developer who wants to become highly effective at building production applications on AWS.

This course treats AWS as the environment your application runs in, not as an infrastructure product to administer. Every service is introduced because a backend engineering problem demanded it.

The learner is not assumed to be:

• an AWS administrator
• a DevOps engineer
• an SRE
• a networking specialist
• a cloud architect
• an AWS certification holder

2. The two axes: AWS knowledge vs engineering experience

These are independent, and the course treats them independently.

quadrantChart
    title Who starts where
    x-axis "Low AWS knowledge" --> "High AWS knowledge"
    y-axis "2-3 YOE" --> "8-10 YOE"
    quadrant-1 "Rare: skim Days 1-3"
    quadrant-2 "PRIMARY AUDIENCE"
    quadrant-3 "Secondary audience"
    quadrant-4 "Not the target"
    "Senior dev, zero AWS": [0.12, 0.88]
    "Mid dev, zero AWS": [0.12, 0.35]
    "Senior dev, some AWS": [0.55, 0.85]

Everyone starts at AWS zero. The course entry point is identical for all learners. What changes with seniority is how deep the reasoning goes in each day's later sections — not which days you read.

Depth ladder applied to every major topic

Worked example — SQS:

Every day's material is written so that a 3-YOE reader stops at "Core Concepts + Hands-on" and still has a complete, correct mental model, while an 8-YOE reader continues into "Failure Scenarios / Trade-offs / Senior-Level Questions" and finds material that is genuinely hard.

3. Assumed software development baseline

Approximately 2–10 years of software development experience, preferably backend.

Language / framework (primary examples throughout):

• Java 17+
• Spring Boot 3.x+
• Maven
• AWS SDK for Java v2 (v1 only appears when discussing legacy migration)

Assumed understood without explanation:

• variables, methods, classes, interfaces, generics
• exceptions and exception handling
• collections
• object-oriented design
• dependency management (pom.xml)
• writing a REST controller

The course never teaches Java or Spring Boot from scratch. When an AWS example needs a Spring concept the learner may not have (e.g. @ConfigurationProperties, a TaskExecutor, a custom HealthIndicator), it gets a two-to-four sentence inline explanation and moves on.

4. Assumed backend baseline

The learner today understands this:

flowchart LR
    C[Client] --> B[Backend API] --> D[(Database)]

and is not expected to understand this:

flowchart TD
    C[Client] --> CF[CloudFront]
    CF --> AG[API Gateway / ALB]
    AG --> CMP[ECS / Lambda]
    CMP --> DB[(RDS / DynamoDB)]
    CMP --> Q[SQS]
    Q --> W[Worker]
    W --> DB

Building the second picture — component by component, with the reason each box exists — is the course.

5. Database baseline

Assumed known: tables, rows, columns, primary keys, foreign keys, indexes, JOINs, transactions, basic normalization.

Taught from first principles (assume zero):

• DynamoDB's data model
• partition key, sort key, composite keys
• GSI, LSI, and why they are not "just indexes"
• item collections and the 10 GB LSI limit
• NoSQL access-pattern-first modeling and single-table design
• eventual vs strong consistency, and what a read actually returns
• hot partitions and adaptive capacity
• distributed database trade-offs

6. Networking baseline

Assumed known: IP address, port, HTTP/HTTPS, DNS at a high level ("names map to addresses").

Taught from zero: CIDR, subnets, route tables, NAT, Internet Gateway, VPC, Security Groups, NACLs, VPC endpoints / PrivateLink, peering, Transit Gateway.

The networking narrative deliberately starts here:

flowchart LR
    L[My Laptop] --> I((Internet)) --> A[AWS] --> App[Application]

and only by end of Day 2 reaches here:

flowchart TB
    subgraph VPC["AWS VPC  10.0.0.0/16"]
        subgraph PUB["Public Subnets (2 AZs)"]
            ALB[Application Load Balancer]
            NAT[NAT Gateway]
        end
        subgraph PRIV["Private Subnets (2 AZs)"]
            APP[Application Service]
        end
        subgraph DATA["Isolated Subnets (2 AZs)"]
            DB[(Database)]
        end
    end
    I((Internet)) --> IGW[Internet Gateway] --> ALB --> APP
    APP --> DB
    APP -->|egress| NAT --> IGW

Networking is taught only to the depth a backend developer needs to explain why their request did or did not arrive. No BGP, no enterprise WAN, no packet analysis.

7. Cloud baseline

Assume little or no AWS experience. The learner may have clicked around the Console or heard of EC2/S3/Lambda; the course relies on none of it.

Conceptual entry sequence, in order:

flowchart LR
    A[What is Cloud?] --> B[Why Cloud?] --> C[What AWS provides] --> D[Global Infrastructure]
    D --> E[AWS Account] --> F[Region] --> G[Availability Zone] --> H[AWS Service] --> I[Your Application]

8. Explicitly NOT required before starting

AWS · AWS certification · DevOps · Kubernetes · Terraform · CloudFormation · Docker · Jenkins · CI/CD · Linux administration · advanced networking · advanced security · Infrastructure as Code · AWS Organizations · enterprise cloud governance.

Each appears only where it explains application architecture. Docker, for example, appears on Day 4 for exactly as long as it takes to package a Spring Boot app for ECS — not as a container course.

9. What this course is not

The repeating shape of every topic is instead:

flowchart LR
    P[Engineering Problem] --> W[Why it exists] --> A[Architecture] --> S[Service Selection]
    S --> I[Implementation] --> IB[Internal Behavior] --> F[Failure Modes]
    F --> PC[Production Concerns] --> T[Trade-offs] --> IR[Interview Reasoning]

10. Practical prerequisites (tooling)

Before Day 1 the learner needs:

Cost discipline is part of the curriculum, not an afterthought. Day 1 sets a billing alarm; every lab has a Cleanup section; Day 12 teaches how a developer accidentally creates a large bill.

11. Time commitment and honest scope

• 14 days × 3–4 hours = 42–56 hours.
• Each day is time-boxed block by block in 04 — 14-Day Curriculum.
• Anything valuable that does not fit is labelled Optional Deep Dive and clearly marked as outside the 42–56 hour budget.

The course is not a 100-hour course pretending to be a 50-hour course. Where depth had to be traded, the trade is stated explicitly in the day's front matter.

Related

• 02 — Prerequisite Assessment — find out whether this baseline actually describes you
• 03 — Optional Foundation Module — 3–5 hours to close gaps if it does not
• 04 — 14-Day Curriculum