
AWS Amplify Explained: Full-Stack Without the Glue
AWS Amplify bundles S3, CloudFront, Cognito, AppSync, and Lambda into one framework — what it actually does, and when it's the right call.
What Amplify actually is
If you've worked through hosting a static site on S3 and CloudFront,
or wiring up Cognito for user sign-in, you already know the honest
truth about building on AWS directly: even a simple app touches a lot
of separate services, and you're the one wiring them together. A
storage bucket here, a CDN in front of it, an identity pool for login,
an API layer, a database, a Lambda function or two for business logic
— each with its own console, its own IAM permissions, its own
configuration surface.
AWS Amplify's whole pitch is: what if you didn't have to assemble that
by hand every time? Amplify is a framework that provisions and wires
together the AWS services a typical web or mobile app needs —
hosting, authentication, an API, a database, file storage, and
serverless functions — from a much smaller amount of code, with the
individual AWS services still there underneath, just no longer
something you're manually gluing together.
What's actually running under the hood
This part matters, because it's not a black box replacing AWS with
something else — it's the same services, provisioned for you:
- Hosting → Amazon S3 for the built assets, Amazon CloudFront in front of it as the CDN. The exact pattern from a hand-built S3 + CloudFront static site, just automated.
- Authentication → Amazon Cognito, configured with sign-up, sign-in, and user groups without you touching the Cognito console directly.
- Data/API → AWS AppSync (a managed GraphQL layer) backed by Amazon DynamoDB, generated from a data model you define, not hand-built resolvers.
- Storage → Amazon S3 again, this time for user-uploaded files, with authorization rules tied back into Cognito.
- Functions → AWS Lambda, for anything that needs custom backend logic beyond what the generated API covers.
Knowing this changes how you should think about learning Amplify: it's
not a separate skill from learning AWS services individually — it's a
faster on-ramp to services you'll eventually want to understand on
their own anyway.
Gen 2: the part that actually changed recently
The original Amplify (now called Gen 1) worked through a CLI wizard —
amplify add api , answer a series of prompts, get a generated
CloudFormation template you weren't really supposed to edit by hand.
It worked, but the backend definition lived partly in your head and
partly in generated files you couldn't easily review in a pull
request.Amplify Gen 2, generally available since May 2024, replaced that with
a code-first model: you define auth, data, storage, and functions
directly in TypeScript files inside your own repository. No CLI
wizard, no generated files to avoid touching — your backend
definition is just code, which means it's reviewable in a PR, testable
like the rest of your codebase, and version-controlled the normal way.
Two Gen 2 specifics worth knowing:
- Per-developer cloud sandboxes. Each developer gets their own isolated backend environment while working locally, so two people iterating on a feature at the same time aren't fighting over a shared dev backend.
- A full-stack environment per Git branch. Push a feature branch, get a complete, isolated deployment — frontend and backend both — automatically. Open a pull request, and reviewers get a live preview environment to actually click through, not just a code diff.
Where this actually helps a developer
- Prototyping speed. Standing up auth, a working API, and file storage for a new idea is a matter of writing a data model and running a deploy, not manually configuring five services in sequence.
- Less glue code to maintain. The wiring between, say, Cognito and an API's authorization rules is generated and kept consistent, rather than something you're hand-maintaining across services.
- PR-based review of infrastructure changes. Because the backend is TypeScript in your repo, a teammate can review a change to your data model the same way they'd review any other code change — not something that only shows up after someone clicks through the AWS console.
- A generated starting point for forms. Amplify can generate React forms directly from a data model, with validation, as a starting point you customize rather than build from nothing.
Where it's genuinely not the obvious choice
Worth being honest about this rather than presenting Amplify as
strictly better than the alternatives. If you're an early-stage team
with no existing AWS footprint, platforms built specifically around a
single framework — Vercel for Next.js, for instance — tend to offer a
smoother day-one experience; Amplify supports Next.js's SSR and ISR
features, but the integration involves more manual configuration
around edge cases than a platform built natively around that
framework. Amplify's real strength shows up once you're already
operating inside AWS — existing IAM structure, existing compliance
requirements, other services you're already using that a new app
needs to talk to. Bolting Amplify onto an already-AWS-native
environment is a much better fit than choosing it purely because it's
the fastest way to get a brand-new, standalone app online.
If you're a student trying this for the first time
The most useful order to learn this in: build something small with
raw S3, Cognito, and a Lambda function or two by hand first, the way
the earlier pieces in this series walked through. Then try Amplify on
a second, similar project. The value of Amplify becomes obvious the
moment you've felt the manual version — you'll recognize exactly which
steps it's doing for you, instead of it just feeling like magic you
don't fully trust.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article