12-Week Engineering Internship · Fundamentals by hand, build with AI

The Builder's Track: twelve weekends, one real platform.

The split is the whole method: weekdays are for fundamentals, learned by hand with AI turned off — the goal is a real mental model, not working code. Then each weekend they use AI to build fast, shipping the next layer of one product, Relay, a team task & insights platform. The rule that ties it together: you can only ship what you understand. This 12-week pace is built for people starting near zero — three gentle weeks up front on the fundamentals most beginners wash out on.

Duration
12 weeks
Starting level
Near-zero code OK
Weekly load
~2–3h/eve + weekend
Outcome
1 shipped platform
01 · How it works

Every week runs on the same rhythm

Predictability is the point, and so is the mode switch. Weekdays are slow and manual — build the mental model by hand, no AI. The weekend flips to fast and AI-assisted — assemble the concepts into something that runs. Same interns, two very different gears.

Mon–Tue

Learn the fundamentals — videos & docs — plus tiny drills by hand. AI off.

Wed–Thu

Rebuild a small example from scratch, from memory. Still no AI — this is where the mental model forms.

Fri

Read the weekend brief, cut a feature branch, ask blocking questions early.

Sat–Sun

The Weekend Build — now AI on. Use it to build fast, ship the increment, open a PR.

Mon review

Checkpoint: PR review + a 15-min demo. Explain any line AI wrote, or it doesn't count.

Fundamentals by hand on weekdays · AI only on weekends One repo, one growing product Every change goes through a branch + PR — from Week 1 You can only ship what you understand "Done" = it runs, it's committed, README updated

Weekdays — fundamentals, by hand

Learn each concept and rebuild small examples yourself, with AI turned off. The output isn't a project — it's a mental model. You should be able to write the core pieces from memory and explain why they work. This is the part most people skip; it's the part that makes the rest stick.

Weekends — build fast, with AI

Now bring in AI assistants to assemble the weekend build quickly — that's a real, valuable skill too. The guardrail: you can only ship what you understand. If you can't explain a line the AI wrote at Monday's review, it doesn't get merged. AI accelerates a foundation; it doesn't replace one.

02 · The through-line

The product grows one layer per week

Relay — a team task & insights platform

git clone relay/ · each weekend commits the next layer
W1Your workshopTerminal, Git, the repo + a project bootstrapper
W2Thinking in codeJavaScript by hand: a data-cruncher script
W3Live static siteHTML/CSS/DOM page live on your domain (Cloudflare Pages)
W4React dashboardNext.js rebuild, redeployed to the same domain
W5The APIYour own backend; the dashboard talks to it
W6Login & rolesReal authentication & access control
W7Real dataPostgres persistence + migrations
W8Fast dataRedis caching, rate limits, pagination
W9The cloudDockerized API on your server at api.yourname.dev
W10AutomationCI/CD: checks on every PR, auto-deploy on merge
W11A brainAI feature grounded in Relay's own data (RAG)
W12An agentAutonomous worker that takes safe actions via tools

▸ It goes public early: the frontend is live on a real domain from Week 3, and the API joins it in Week 9. Every mentee has a URL to show from the first weekends on.

03 · Day one

Claim your free stack — before Week 1

The very first task, on day one, is paperwork: apply for the GitHub Student Developer Pack. Approval can take up to ~72 hours, and it unlocks the free domain and cloud credits the hosting thread depends on. Get it in early so nothing is blocked when the first weekends arrive.

① GitHub Student Developer Pack

Apply at education.github.com/pack. Requires proof of enrollment — a school email or a photo of a student ID / enrollment letter. One approval unlocks everything below.

② A free domain (1 year)

Via Name.com / Namecheap in the pack — extensions like .me .tech .app .dev. This is the URL mentees show people. Claim one good name and build everything on it.

③ Cloud credit for the server

The pack includes DigitalOcean credit (recently ~$200 for a year; also Azure for Students). Funds the Week 9 server + database. Amounts and deadlines change — check the current offer when applying.

④ Cloudflare Pages — free, no pack needed

Hosts the frontend on a global CDN with automatic HTTPS, and redeploys on every git push. This is where the Week 3 site goes live.

⑤ GitHub Pro + Codespaces

Free while verified: private repos and ~120 hours/month of a ready-to-code browser environment — handy for mentees on weak laptops.

Not enrolled anywhere?

The pack needs student status. Without it: Cloudflare Pages is still free, the *.pages.dev URL works fine, and a domain is ~$10/year. The plan doesn't break — you just pay a little.

How the hosting fits together

one domain · two subdomains · HTTPS everywhere
WEByourname.devFrontend → Cloudflare Pages (auto-deploys from GitHub), from Week 3
APIapi.yourname.devBackend + database → your cloud server, from Week 9
04 · The twelve weeks

Weekly plans & weekend builds

Weeks 2–4 (amber) are the fundamentals on-ramp — slow and deliberate, because this is where beginners usually wash out. Don't rush them.

Week01
Terminal, Git & Your Workshop

Be dangerous in the terminal, and never lose work again.

Concepts

  • Day 1: apply for the GitHub Student Developer Pack (see section 03)
  • Shell basics (bash/zsh): navigation, files & permissions, pipes, environment variables
  • SSH keys — connecting to GitHub
  • Git for real: branches, commits, merge vs. rebase (concept), resolving conflicts
  • Collaboration: commit-message conventions, PR templates, code-review etiquette

Resources

◆ Weekend Build
Project Bootstrapper CLI
Builds on ▸Foundation

A bash/zsh script new-project.sh that scaffolds a project: makes the folder structure, writes a .env.example, initializes git, installs a commit-message lint hook that rejects messages not starting with feat|fix|docs|chore, and prints next steps.

Deliverables
  • The bootstrapper script
  • A GitHub repo named relay
  • CONTRIBUTING.md + a PR template
Acceptance criteria
  • Running the script produces a ready repo
  • A bad commit message is rejected
  • First PR merged via the template

Stretch ▸ add a --with-ssh flag that generates and prints a deploy key.

✓ CHECKPOINT

Walk through your git history. Explain one merge conflict you caused on purpose and how you resolved it.

Ramp02
Programming Foundations: JavaScript by Hand

Think in code — variables, logic, and data — before any framework.

Concepts

  • Values & types; variables; operators
  • Functions — arguments, return values, scope
  • Arrays & objects; map/filter/reduce
  • Conditionals & loops
  • Async/await & fetch
  • Reading error messages; using console & the debugger

Resources

◆ Weekend Build
Relay Data Cruncher (CLI)
Builds on ▸W1 repo & PR flow+ JavaScript

A small Node script that fetches tasks from a public API and prints useful stats — counts by status, how many are overdue, totals per assignee. Pure JavaScript, no framework. Written by hand on weekdays; AI only helps polish it on the weekend.

Deliverables
  • scripts/ Node file in the repo
  • Runs with node
  • A README usage line
Acceptance criteria
  • Correct stats from live API data
  • Handles an empty or failed fetch
  • Every line is explainable

Stretch ▸ accept a CLI flag to filter by assignee.

✓ CHECKPOINT

Run it live, then change a requirement on the spot ("now group by week") and watch them modify it — that's the real test of understanding.

Ramp03
The Web, By Hand: HTML, CSS & the DOM — First Deploy

Build a real web page from scratch and put it online on your own domain.

Concepts

  • Semantic HTML structure
  • CSS flexbox/grid & responsive layout
  • The DOM: selecting elements, events, updating the page with vanilla JS
  • fetch → render into the page; loading & error states
  • Static hosting on Cloudflare Pages; custom domains & DNS basics

Resources

◆ Weekend Build · goes live
Relay Board v0 — live on your domain
Builds on ▸W1 repoW2 JS+ HTML/CSS/DOM + hosting

A responsive page (HTML/CSS + vanilla JS) that fetches tasks and renders a list + detail view with loading and error states. Then deploy to Cloudflare Pages and connect your Student-Pack domain — it's live and shareable by Sunday night.

Deliverables
  • apps/web static site
  • Live at yourname.dev
  • Live URL in the repo README
Acceptance criteria
  • Reachable over HTTPS
  • A git push redeploys it
  • Responsive; handles API failure

Stretch ▸ a simple filter / search box.

✓ CHECKPOINT

Open their live domain together. Resize to mobile, then break the API and confirm the error state shows instead of a blank page.

Ramp04
React & Next.js: The Dashboard

Rebuild the page as a component-driven app you can grow.

Concepts

  • Why frameworks: state → UI, instead of hand-updating the DOM
  • Components & props; composing UI
  • Hooks: useState, useEffect
  • Next.js: routing, client vs. server components
  • Migrating vanilla JS → React deliberately

Resources

◆ Weekend Build
Relay Dashboard (React / Next.js)
Builds on ▸W3 live site+ React / Next.js

Rebuild the Week 3 board as a Next.js app with real components and hooks, then redeploy to Cloudflare Pages on the same domain. Same features — better structure you can build on.

Deliverables
  • Next.js app replacing the static site
  • Still live at the same domain
  • Clean component structure
Acceptance criteria
  • Feature-parity with Week 3
  • Redeploys on push; no console errors
  • Components, not one giant file

Mobile track ▸ a React Native + Expo shell showing the same task list.

✓ CHECKPOINT

Ask them to add one new field to the task card live. Whether it's a clean one-component change or a copy-paste scramble tells you if React actually landed.

Week05
Backend & REST APIs

Stand up your own API the frontend can talk to.

Concepts

  • Server basics with Node/Express or Python/FastAPI — pick one, commit to it
  • REST design: methods, status codes, routes
  • Request validation; clear error responses
  • Middleware; JSON in / JSON out

Resources

◆ Weekend Build
Relay API v1
Builds on ▸W4 dashboard+ your own backend

An API with validated GET/POST /tasks (in-memory for now). Point the dashboard at your API instead of the public one.

Deliverables
  • apps/api
  • A documented endpoint list
  • Dashboard reads/writes your API
Acceptance criteria
  • Correct status codes
  • Invalid payloads rejected with clear errors
  • Frontend works against it

Stretch ▸ add PATCH and DELETE for tasks.

✓ CHECKPOINT

Hit the API with curl or Postman together. Send a deliberately bad payload and read the error response.

Week06
Authentication & Authorization

Add real login and roles — safely.

Concepts

  • Password hashing (never plaintext)
  • Sessions vs. tokens; JWTs — issue, verify, expiry
  • Role-based access: admin vs. member
  • Protecting routes with middleware

Resources

  • JWT introduction
  • OWASP — Authentication Cheat Sheet (concepts)
  • Your framework's auth guide
◆ Weekend Build
Relay Auth
Builds on ▸W4 UIW5 API+ auth & roles

Add POST /register, POST /login (returns a JWT), protect /tasks, and add member/admin roles. Add a login flow to the dashboard.

Deliverables
  • Auth endpoints
  • Role checks on protected routes
  • Dashboard login flow
Acceptance criteria
  • Unauthenticated requests rejected
  • Members can't hit admin routes
  • Passwords hashed, never plain
  • Login works end-to-end

Stretch ▸ refresh tokens + logout.

✓ CHECKPOINT

Mentor tries to break it live — missing token, wrong role, tampered JWT. Intern explains each fix.

Week07
Databases: Postgres & an ORM

Make data survive restarts with a real database.

Concepts

  • Relational modeling: tables, keys, relationships, normalization
  • SQL basics: select / insert / join
  • Indexes; ACID in plain terms
  • ORM + migrations (Prisma, or SQLAlchemy + Alembic)

Resources

◆ Weekend Build
Relay Persistence
Builds on ▸W5 APIW6 auth+ Postgres & migrations

Move users & tasks into Postgres via an ORM with real migrations. Add a seed script. The API now reads and writes a real database.

Deliverables
  • Schema + migration files
  • A seed script
  • API backed by the DB
Acceptance criteria
  • Data survives a restart
  • Relationships enforced (a task belongs to a user)
  • Migrations run clean from scratch

Stretch ▸ add one index and explain what it speeds up.

✓ CHECKPOINT

Read the schema together. Ask: "What happens if two users edit the same task at once?"

Week08
Caching & Performance: Redis

Make it fast, and resilient under load.

Concepts

  • What caching is and when to use it
  • Redis basics; caching hot queries + invalidation
  • Sliding-window rate limiting
  • Offset pagination

Resources

◆ Weekend Build
Relay Cache + Limits
Builds on ▸W7 database+ Redis

Cache the task list in Redis with correct invalidation, rate-limit login attempts, and paginate the task endpoint. Wire paging into the dashboard.

Deliverables
  • Cache layer + invalidation on write
  • Rate-limit middleware
  • Paginated endpoint + UI paging
Acceptance criteria
  • Repeat fetches hit cache (prove it in logs)
  • Rapid logins get throttled
  • Large lists paginate correctly

Stretch ▸ per-user cache keys with correct invalidation.

✓ CHECKPOINT

Hammer the login endpoint together and watch the throttle kick in. Check the logs for cache hits vs. misses.

Week09
Docker & the Cloud

Package the backend and run it on your own server, under your domain.

Concepts

  • Docker: Dockerfiles, multi-stage builds, .dockerignore
  • docker-compose: api + Postgres + Redis together
  • A cloud server (DigitalOcean droplet on Student-Pack credit): SSH, firewall
  • DNS in practice: point api.yourname.dev at it; HTTPS (Caddy / Nginx + Let's Encrypt)

Resources

  • Docker — Get started
  • docker-compose docs
  • DigitalOcean — "deploy with Docker Compose" droplet guide
  • Your DNS host — how to add an A record for a subdomain
◆ Weekend Build · the API goes live
Relay API on your own server & subdomain
Builds on ▸W3 live frontendW5–8 backend+ Docker, server & DNS

Dockerize and compose the backend, deploy it to a server, point api.yourname.dev at it with HTTPS, then repoint the Cloudflare Pages frontend to the live API. Now the whole product is real and public.

Deliverables
  • Dockerfiles + compose file
  • A DEPLOY.md runbook
  • API live at api.yourname.dev
Acceptance criteria
  • docker compose up runs backend locally
  • API over HTTPS on the subdomain
  • Frontend ↔ API end-to-end
  • Only ports 80/443/SSH open

Stretch ▸ a managed Postgres instance instead of a containerized one.

✓ CHECKPOINT

Open yourname.dev together — frontend and API on one domain. Ship a one-line change and redeploy while you watch.

Week10
CI/CD & Automation

Make shipping boring — automated checks and hands-off deploys.

Concepts

  • CI vs. CD vs. Continuous Deployment — what each means
  • GitHub Actions: workflows, triggers, jobs, runners, secrets
  • Quality gates on PRs (lint + build + tests); auto-deploy on merge to main

Resources

◆ Weekend Build
Relay Zero-Touch Pipeline
Builds on ▸W1 PR flowW9 server+ CI/CD

A CI workflow that blocks merges unless lint + build pass, and a CD workflow that updates the server on merge to main. Note the contrast: the Pages frontend already auto-deploys on push (managed for you), while the server needs a pipeline you build yourself.

Deliverables
  • .github/workflows/*
  • Branch protection enabled
  • A green pipeline on the PR
Acceptance criteria
  • A failing lint blocks the merge
  • Merge to main updates the live server — no manual SSH

Stretch ▸ add a small automated test suite and gate on it.

✓ CHECKPOINT

Break the build on purpose in a PR. Confirm the gate stops it from merging.

Week11
AI Foundations & RAG

Add a real AI feature grounded in your own data.

Concepts

  • Foundation models & tokens; calling an LLM API safely (keys server-side only)
  • Embeddings & vector search; pgvector — you already have Postgres
  • Retrieval-Augmented Generation: retrieve relevant tasks, then answer

Resources

  • Your model provider's API quickstart
  • A "What is RAG?" primer
  • pgvector README
◆ Weekend Build
Ask Relay
Builds on ▸W4 UIW5 APIW7 Postgres+ pgvector & RAG

An "Ask Relay" panel: users ask natural-language questions ("what's overdue for the design team?") and get answers grounded in their real tasks via retrieval.

Deliverables
  • An /ask endpoint
  • Embedding + retrieval code
  • A chat UI in the dashboard
Acceptance criteria
  • Answers use real task data
  • API key never exposed to the client
  • Off-topic questions handled gracefully

Stretch ▸ stream the response token-by-token.

✓ CHECKPOINT

Ask it something its data can't answer. Check it doesn't confidently hallucinate.

Week12
Agentic Finale & Capstone

Turn the AI feature into an agent that acts — then harden and present.

Concepts

  • Function/tool calling; the tool-execution loop; guardrails
  • Agent frameworks (LangChain, or a lightweight loop) — concept + one real tool
  • Production readiness: logging, observability, secrets hygiene, README, demo

Resources

  • Your provider's tool-calling / function-calling guide
  • A short LangChain (or minimal-agent) tutorial
  • The Twelve-Factor App — config & secrets
◆ Weekend Build · Capstone
Relay Agent + Final Polish
Builds on ▸W1W2–4W5–8W9–10W11+ agent

An autonomous worker that queries task metrics and takes a safe action via tool calling — e.g. auto-tag overdue tasks and post a daily summary. Then harden: logging, error handling, a real README with an architecture diagram, and a recorded 5-minute demo.

Deliverables
  • The agent with ≥ 1 real tool
  • Structured logs
  • Polished README + architecture diagram
  • A 5-minute demo video
Acceptance criteria
  • Agent completes a full loop with no manual steps
  • Every action is logged
  • A stranger can clone & run it from the README

Stretch ▸ a second tool + an approval step before the agent acts.

✓ CAPSTONE

5-minute live demo + 5-minute Q&A on the architecture and one thing they'd redesign if starting over.

About this pace — the 12-week track

This version assumes people starting from near-zero code, moving at a few evenings plus one weekend per week. It front-loads three gentle weeks (W2–W4) on programming and web fundamentals precisely because that's where beginners wash out. If your group already codes, compress toward 8 weeks by merging pairs: W2+W3 (JS + web basics), W7+W8 (data + cache), and W11+W12 (AI + agent). The non-negotiable is the pattern: learn by hand on weekdays, build with AI on weekends, review Monday, and never break the chain from prior weeks. And if even 12 weeks feels tight, spend two weekends on a hard week rather than letting anyone paste through it.

05 · How you grade a weekend

The review rubric

Score each weekend build on five axes, 0–3 each. This keeps feedback objective and shows progress over time. Total ≥ 11/15 is a solid ship.

Axis0 — Not yet3 — Strong
It shipsDoesn't run / not committedRuns, committed, README updated
ExplainableCan't explain AI-written linesWalks through every line & decision
Git & PR hygieneOne giant commit on mainClean branch, good messages, PR
Builds on prior weeksRewrote / broke earlier layersExtends the same codebase cleanly
Handles failureCrashes on bad inputGraceful errors & edge cases
06 · For the mentor

Running the program well

Review the PR, not the person

Comment on the diff. Keep feedback about the code, specific and actionable. It teaches them how real teams work.

Prefer questions to corrections

"What happens if this request has no token?" teaches more than "add a guard here." Let them find it.

Timebox the rescue

Let them struggle ~30 minutes before you step in. Struggle is where the learning lives — abandonment isn't.

Watch for AI over-reliance

The tell isn't how code was written — it's whether they can explain a variable's purpose, modify it live, and say why an alternative was rejected. If not, it didn't land.

Celebrate the merge

Every merged PR is a shipped feature. Name it, share the live URL. Momentum is the real curriculum.

Protect the chain

The magic is cumulative. If someone falls behind, help them catch the last layer — never let them start a fresh throwaway project.