AWS Builder Center
Two Minutes a Day: How I Got an AI to Teach subscribers AWS Every Night

Two Minutes a Day: How I Got an AI to Teach subscribers AWS Every Night

A fully serverless AWS lesson generator: Claude on Amazon Bedrock writes a brand-new AWS lesson every single night, no human writer involved. Built for anyone trying to break into AWS who thinks they don't have the time — two minutes a day is all it takes, and the archive is always there waiting if you fall behind.

Senior DevOps Engineer | AWS Community Builder (Networking) | Terraform • CI/CD • Hybrid Infra
I built a system that teaches me a new AWS concept every single night — automatically, without fail, so "I don't have time" stops being an excuse. Here's the whole build.



The Idea: One AWS Lesson a Day, No Course Required

I already had WordSprout teaching my kid five vocabulary words a day. The same shape of problem — a tiny daily habit, reinforced by a searchable archive, powered by AI running quietly in the background while everyone sleeps — felt like exactly what I needed for something else: staying sharp on AWS itself.
That's TechSprout: a private, invite-only site that publishes one AWS-focused technical lesson every night, built for anyone trying to break into AWS who keeps telling themselves they don't have the time to start. No content calendar, no writer, no editorial backlog to manage — Claude, running on Amazon Bedrock, writes the lesson every single night, and the entire thing runs on a 100% serverless AWS stack.
It's WordSprout's sibling in almost every architectural decision — same serverless shape, same Terraform style, same "one Lambda per job" philosophy — except for the two places I deliberately diverged: real, server-side authentication (WordSprout doesn't have any), and two Lambdas instead of one. Everything else you're about to read is either a faithful mirror of a proven pattern, or a scar from a bug that made me change my mind mid-build.



Two Minutes a Day. Zero Excuses. No Catching Up Required.

"I don't have time to learn AWS" is the single biggest lie almost every aspiring cloud engineer tells themselves — right before closing the tab on a six-hour certification course they were never going to finish. TechSprout exists to kill that excuse outright. It isn't built for people who already know AWS and want a refresher; it's built purely for the newcomer — the new joiner staring at the AWS console for the first time, completely unsure where to even begin.
The entire commitment is two minutes a day. One lesson, one AWS service or concept, start to finish, in less time than it takes to make coffee. No lecture, no video to scrub through, no course platform demanding a weekend you don't have. And if life happens and a day gets missed — no guilt, no penalty, no starting over. The archive keeps every single lesson, searchable and waiting, so picking up tomorrow — or next week — is exactly as easy as reading today's.
Every lesson is also written for someone starting from zero, not someone brushing up. Nothing is assumed. Each concept is unpacked in a genuinely detailed, plain-language, no-jargon-first way — a real analogy before a single technical term shows up, then the mechanics, then where it actually gets used in the real world — so a complete newcomer can walk away not just having read about a service, but actually understanding it well enough to use it. And for topics where a picture genuinely helps — architecture patterns, multi-service flows — a handful of lessons come with an auto-generated diagram alongside the text, not just words on a page.
And here's the part that makes the whole promise possible: nobody is writing this by hand, and nobody has to remember to. Instead of a human sitting down every single day to research and draft an article, that entire job has been fully automated — end to end, through AWS and Amazon Bedrock. Every night, without fail, a brand-new lesson is generated automatically and is sitting there, ready, the moment readers wake up. No missed days. No "sorry, behind on content this week." Just a new lesson, every single day, on autopilot.



What TechSprout Actually Does

  • 📚 One AI-generated lesson a night, every night — always the same 8-section shape: what it is, a plain-language analogy before any jargon, brief history, how it works, industry usage today, advantages, disadvantages, and when (not) to use it
  • 🖼️ Conditional architecture diagrams — Stability AI generates one only for topics that are actually diagram-worthy (multi-service patterns, architecture styles), decided by a combination of pre-tagged topics and the model's own judgment call at generation time
  • 🔒 Actually private, not just login-gated — every page and every API route requires a valid session, checked server-side on every single request, including the "what's today's lesson" endpoint that a lazier build would leave wide open
  • 🔁 Never repeats a topic, permanently — a ~104-topic AWS backlog seeded across Compute, Containers, Storage, Database, Networking, Security, Application Integration, Analytics, ML/AI, Management & Governance, Developer Tools, and Architecture Patterns, each one flagged  generated  forever once used
  • 🔍 Instant client-side search — Fuse.js fuzzy-searching a lightweight JSON index, zero backend search service, zero extra infrastructure
  • 🌍 Global, fast, and secure by default — CloudFront + ACM + Route 53 on a custom subdomain, HTTPS end to end
  • 🧮 Two live counters, atomically updated — subscriber count and total reads, incremented with DynamoDB's atomic  ADD  (not read-modify-write, so concurrent readers never clobber each other's counts)
And the nightly job is idempotent by design: it checks whether today's lesson already exists before touching Bedrock, so it's completely safe to trigger manually — which turned out to matter a lot, because I ended up doing exactly that, repeatedly, while chasing down the bugs below.



The Architecture: Two Lambdas Instead of One

WordSprout multiplexes everything — scheduled generation and the read API — through a single Lambda that branches on the incoming event shape. TechSprout splits that in two on purpose: a content-generation Lambda that only EventBridge Scheduler ever invokes, and a completely separate read/auth API Lambda that only API Gateway ever invokes. Smaller blast radius, cleaner and more scoped IAM roles per function, and — critically — a generation function that's allowed to actually fail loudly instead of quietly falling back to placeholder content the way WordSprout's shared Lambda does on error.
Two pipelines, numbered end to end: Pipeline 1 (bottom-left) is the fully automated nightly run — EventBridge Scheduler wakes the content-generation Lambda, which picks a topic, calls Claude for lesson text, optionally calls Stability AI for a diagram, and writes the result to DynamoDB and S3. Pipeline 2 (top) is the on-demand reader path — a browser resolves DNS, loads the static site off CloudFront, and calls the API Gateway-fronted Lambda for everything dynamic, gated by a session check on every route. The three colored region zones aren't a stylistic choice — each one is a real constraint the deployment forced, covered in the war stories below.
AWS Service
Role in TechSprout
AWS Lambda (Python 3.11) × 2
Content generation (nightly, EventBridge-only) + read/auth API (every request, API Gateway-only)
API Gateway (HTTP API, payload format 2.0)
Routes every frontend request to the api Lambda — see below for why that version number is load-bearing
DynamoDB × 4 tables
Lessons, topic backlog, users, aggregate stats — all pay-per-request, zero GSIs
S3 × 2 buckets
Static React frontend + generated diagram images, each behind its own CloudFront cache behavior
CloudFront
Global CDN, HTTPS, custom domain — two origins, one per bucket,  /diagrams/*  routed separately
Route 53
DNS for the custom subdomain, reusing WordSprout's existing hosted zone
Amazon Bedrock
Claude Sonnet 5 (+ Haiku 4.5 fallback) for lesson text, Stability SD3.5 Large for diagrams
EventBridge Scheduler
Triggers the nightly generation job — the modern successor to classic CloudWatch Event Rules
ACM
SSL certificate, provisioned in us-east-1 (CloudFront's one non-negotiable requirement)
No servers, no containers, nothing idle at 3 AM. And nothing here is fictional infrastructure-as-marketing — every resource in that table exists, right now, in a real AWS account, because I  terraform apply 'd it live while writing this.



War Story #1: AI Models Are a Moving Target

Lesson generation runs on Claude — the same model family WordSprout already uses successfully. Even settling on Claude wasn't a one-shot decision, though. The first Claude model picked had already reached end of life by the time it got deployed (Claude 3.5 Sonnet, an October-2024 release — on this platform, eighteen months is a long time). The next one picked failed with  ResourceNotFoundException  because current-generation Claude models on Bedrock are inference-profile-only — no bare on-demand  modelId  accepted at all, only  us.anthropic.claude-sonnet-5 -style profile IDs. Each failure mode was confirmed live against the actual account via  boto3.client("bedrock").list_inference_profiles() , not guessed from documentation that might already be stale by the time anyone reads it.
TechSprout now runs on  global.anthropic.claude-sonnet-5 , with  global.anthropic.claude-haiku-4-5  as a cheaper fallback if the primary call fails.
The lesson: on a platform shipping new models monthly, "the model that worked in the tutorial" and "the model available to your account, right now, in this region" are two completely different questions. Always check both, live, against the account you're actually deploying to.



War Story #2: One Stack, Three Regions

Midway through, I migrated the whole stack from  us-east-1  to  ap-southeast-1 , matching WordSprout. That single decision surfaced two more region-specific landmines:
  • Stability AI's base text-to-image model doesn't exist in  ap-southeast-1  at all — a live  list_foundation_models()  call returned zero Stability models for that region, for this account. It was also quietly retired from  us-east-1 ; only specialized editing tools remain there now (upscale, inpaint, background removal — all of which need an existing image as input, none of which can generate one from scratch). A region-by-region sweep found  stability.sd3-5-large-v1:0  still  ACTIVE / ON_DEMAND  in exactly one place:  us-west-2 . So the diagram-generation call in  bedrock_image.py  deliberately targets a third region — the only genuinely cross-region call in the whole pipeline, image bytes still landing back in the main-region S3 bucket.
  • Recreating S3 buckets with the exact names just deleted from  us-east-1  hung for 20+ minutes mid- terraform apply . AWS's global bucket-namespace release has no fixed SLA, and Terraform will happily sit there retrying forever. The fix wasn't patience — it was accepting that the name was gone and picking a new one ( -sg  suffix) instead of waiting out an indeterminate AWS-side delay.
End result: DynamoDB, both Lambdas, API Gateway, S3, EventBridge Scheduler, and Claude text generation all run in  ap-southeast-1 ; the ACM cert lives in  us-east-1 ; the Stability diagram call runs in  us-west-2 . One project, three regions, and every single one of them earned through a real error message rather than assumed up front from documentation.



War Story #3: The Silent Default That Broke Every Route

This is the one that took the longest to find, precisely because nothing about it looked broken. Every API call returned a clean, correctly-formatted  401 {"success": false, "message": "Authentication required"}  — even a login attempt, even with the right username and password. No stack trace, no 5xx, no CloudWatch error. Just every single request, regardless of path or method, quietly falling into the "you're not authenticated" branch.
The actual bug:  aws_apigatewayv2_integration  defaults to Lambda payload format 1.0 unless you explicitly set  payload_format_version = "2.0" . My handler only ever parsed the 2.0 event shape ( event["requestContext"]["http"]["method"] ,  event["rawPath"] ) — fields that simply don't exist in a 1.0 payload. With format 1.0,  method  and  path  silently fell back to their defaults ( "GET"  and  "/" ), so  path == "/login" and method == "POST"  was always false, no matter what actually hit the API.
Diagnosed by invoking the Lambda directly with  aws lambda invoke  and a hand-built synthetic 2.0 event — got the correct "invalid credentials" response instantly, proving the handler logic itself was fine. Then invoked it through real API Gateway with the exact same request — got the wrong branch every time. That delta is what pointed straight at the integration layer instead of the code. One line fixed it:
resource "aws_apigatewayv2_integration" "lambda_integration" {
integration_type = "AWS_PROXY"
payload_format_version = "2.0" # <- the whole bug, in one line
}



War Story #4: Two More Terraform Landmines

Two smaller but equally real gotchas, both discovered the same way — by actually running  terraform apply  against a live account instead of trusting the plan looked reasonable:
  • S3 Block Public Access is on by default for new buckets in this account. The public-read bucket policies for the frontend and diagram buckets failed with  AccessDenied: ...because public policies are prevented by the BlockPublicPolicy setting . Fix: an explicit  aws_s3_bucket_public_access_block  resource per bucket, all four flags set to  false , with the bucket policy resource  depends_on  it.
  • Terraform won't redeploy Lambda code without  source_code_hash . Without it wired to  filebase64sha256(zip_path) ,  terraform apply  sees an unchanged  filename  argument and assumes nothing changed — even when the zip's contents are completely different. Every mid-project Lambda code fix silently failed to actually deploy until this was added, for both functions.
Neither bug announces itself. Both just look like "it deployed fine" right up until the behavior doesn't match the code you just wrote.



Data Model: Four Tables, One Permanent Flag

Table
Partition Key
Stores
 techsprout_lessons 
 date  (SGT)
The 8-section lesson body, topic, slug, summary, optional diagram key
 techsprout_topics 
 topic 
~104-topic backlog, with a permanent  generated  flag — never resets, unlike WordSprout's rolling 30-day word exclude
 techsprout_users 
 username 
bcrypt password hash, role, lockout state, active flag
 techsprout_stats 
 stat_id  (single row)
Two atomically-updated counters: subscriber count, total reads
The permanent-flag choice over WordSprout's rolling window is deliberate: at one lesson a day, a 104-topic backlog lasts over three months, and a technical lesson repeating within a year reads very differently than a vocabulary word repeating within a month. When the backlog eventually runs dry, the pipeline asks the model to propose a brand-new topic — passing every existing topic name as an exclude list — and pre-flags the result  generated = true  on insert, so it's immediately safe from ever repeating.



Actually Private, Not Just Login-Gated

WordSprout's API has no server-side auth check on its main route at all — fine for a kids' vocabulary app sitting behind a login screen, not fine for anything I'd call "actually secure." TechSprout enforces a valid session on every route except  /login :
  • Passwords hashed with bcrypt, not SHA-256
  • Login issues an HMAC-signed session token (30-day expiry — persistent sessions, not constant re-authentication) verified on every subsequent request, functioning as a lightweight in-Lambda authorizer without needing a separate authorizer resource
  • Account lockout after 3 failed attempts, auto-unlocks after 15 minutes, with a clean-slate reset on unlock rather than an immediate re-lock on the very next attempt
  • No self-service signup, ever — an admin CLI ( user_manager.py ) provisions every reader account interactively, with passwords always entered via a hidden terminal prompt ( getpass ), never as a command-line argument that would end up in shell history



Infrastructure as Code

Same flat Terraform style as WordSprout — one  main.tf , one  outputs.tf  — plus one addition WordSprout didn't need: a second, aliased  aws  provider that exists purely for the cross-region ACM certificate.
provider "aws" {
region = "ap-southeast-1"
}
provider "aws" {
alias = "us_east_1"
region = "us-east-1"
}
resource "aws_acm_certificate" "cert" {
provider = aws.us_east_1
# ...
}
Standing up the whole stack:
cd terraform
terraform init
terraform plan
terraform apply
The nightly job needs zero manual intervention afterward — EventBridge Scheduler fires it, DynamoDB's idempotency check handles the rest. Redeploying Lambda code is a  terraform apply  away too, as long as  source_code_hash  is actually wired up (see War Story #4).



Security, Honestly

This is a personal project, not an enterprise system, and I'd rather say so plainly than oversell it:
  • IAM roles use broad managed policies ( AmazonDynamoDBFullAccess ,  AmazonBedrockFullAccess ) rather than tightly-scoped per-table permissions — fine for a single-project account, not what I'd ship for a team
  • No DynamoDB backups or S3 versioning — accepted deliberately for a ~$1–2/month hobby project
  • Session tokens are a hand-rolled HMAC scheme, not a battle-tested library — deliberately simple, verified with unit tests, but worth knowing it's homemade
  •  terraform.tfstate  holds real resource ARNs and stays out of version control, same as WordSprout
Calling out the gaps matters more than pretending they don't exist — especially for anyone using this as a reference architecture.



Try It Yourself

Access is invite-only by design — there's no public signup, so the links above won't get you past the login screen without an admin-provisioned account. The source is there to read, fork, and learn from. Want in?  DM me on LinkedIn .



What's Next for TechSprout

  • Scoping IAM policies down from full-access managed policies to per-table least privilege
  • A "reader digest" email so subscribers don't have to remember to check in every morning
  • Maybe, eventually, spaced repetition on top of the archive — the same seed WordSprout is still waiting to sprout



Closing Thought

TechSprout started as a simple question — "can WordSprout's shape teach me AWS instead of vocabulary words?" — and turned into a genuinely useful reminder that on a platform moving this fast, half the engineering work isn't writing the code, it's discovering which model, which region, and which API default is actually live today. Every constraint in this build came from a real error message, chased down against a real account, not assumed from a doc that might already be out of date. That's the only way I'd trust a stack like this enough to actually read it every morning.
Built for anyone who wants to start their AWS journey today, two minutes at a time — no excuses, no catching up required.
Want to explore more of what I've built? Visit  satyajitlembhe.com .
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article