The full week-by-week structure for all three tracks, scaled by age rather than shrunk to fit one format. High school and middle school run twelve weeks, once a week, two hours a class. Elementary runs eight weeks, shorter sessions, and needs a parent in the room, because that's what actually fits the age, not because it's unfinished. All three taught by one founder.
A ninth grader and a sixth grader are not the same student, and teaching them off the same lesson plan is how well-meaning programs lose half a cohort by week three. High school and middle school run on the same twelve-week, once-a-week, two-hour cadence on purpose: one founder and one venue means that schedule has to repeat cleanly across both. What changes is the content itself, not just the pace. Middle schoolers build in Scratch instead of a command line and meet databases through a card-sorting activity instead of a live MongoDB connection, the same split Code.org's own K-12 framework draws between real code for grades 9–12 and block-based tools for grades 6–8, formalized in the CSTA K-12 CS Standards. Elementary is being scaled down the same way and isn't finished yet; that section below is a placeholder until it is.
Two hours a week, plus an optional Saturday (or a second weekday) drop-in lab for students who want more hands-on time. The program runs twice a year, fall and spring, in person only, capped at fifteen students so the founder can actually work with everyone in the room.
Professional-readiness warm-up.
Core technical content.
Wrap and reflection.
Setup, icebreakers, goal-setting, and the professional-communication rubric everyone is held to for the next twelve weeks. Optional guest slot: the founder's own path, Year Up to Expeditors to Progressive Insurance.
File systems, operating-system navigation, and professional email basics, including Outlook.
Basic formulas and cell references: SUM, AVERAGE, COUNT, worked through a dataset students actually care about, like sports stats.
Sorting, filtering, and basic tables, framed as what they are: a spreadsheet is a small, single-table database. Sets up the question the rest of the program answers, what happens when data gets too big or too connected for one spreadsheet. Skill check 1: build a tracking sheet using formulas and filters.
Command-line basics (cd, ls/dir, pwd) and a light, guided introduction to Python syntax.
Rows and columns versus documents versus graphs, and why each shape exists. Cloud free tiers only, MongoDB Atlas M0 and Neo4j AuraDB Free, no local Docker to install or fight with. Digital portfolio and resume basics kick off here too.
Documents and collections, with a live, guided Atlas setup. Insert and read through the UI first, before any query syntax.
Real queries, and why a company actually uses this, called straight back to week 4's spreadsheet filtering. Skill check 2.
Why connections matter, tied to the same territory modern AI recommendation and fraud-detection systems run on, which happens to be the founder's actual day job. Live, guided AuraDB Free setup.
Queries against a standard sample dataset, compared directly against the MongoDB queries from week 8. Skill check 3.
Using a pre-built AI tool against structured data, not building one from scratch. Students start planning their capstone.
Five minutes each, then program close: completion certificates and a feedback round.
Assessment stays light on purpose: three pass/fail skill checks, at weeks 4, 8, and 10, plus informal engagement tracking across all twelve weeks. The one piece that gets an actual rubric is the week 12 capstone.
Every student leaves with one thing they built and can explain in an interview. That is the one deliverable that isn't optional.
Same twelve-week, once-a-week, two-hour cadence as Track A, on purpose, one founder and one venue means the schedule has to repeat cleanly across both cohorts. The content underneath it is not Track A run slower. It's built for this age from the ground up, scaled down rather than shortened. Cohorts cap at ten to twelve students, smaller than high school's fifteen, and the optional lab session is more likely to be parent-coordinated at this age.
The same ground Track A covers in four weeks, compressed into three and built for this age directly, not sped up. Typing practice through games, file and folder organization as a digital scavenger hunt, email basics with a mock inbox, and simple Google Sheets framed as organizing a personal collection like trading cards or game stats, sorting and filtering only, no formula emphasis.
Sequencing, loops, conditionals, and sprites, building toward a simple game or story. Replaces Track A's command-line unit entirely, the real precedent being Code.org's national framework, which splits real code for grades 9–12 from block-based tools for grades 6–8, formalized in the CSTA K-12 CS Standards.
The same conceptual jump as Track A's spreadsheet-to-database framing in week 4, delivered visually here instead of through a command line: this list is a tiny database.
A physical "digital binder" activity. Index cards stand in for documents, folders for collections, and students sort and group by shared fields, no real MongoDB involved. Even the beginner tiers of tools like it still assume a command-line comfort this age hasn't built yet, which is why they're skipped deliberately, not out of caution.
A tabletop "connections map": yarn and index cards mapping friends and interests as nodes and relationships, played out as a six-degrees-style game.
Adult-supervised, structured time with a kid-safe AI chat interface, ground rules set first: never share personal information, the AI can be wrong, always double-check. Tied back to weeks 4 through 6, students ask the tool for help debugging or extending their own Scratch project.
Students demo their Scratch project plus one artifact from the weeks 7 and 8 activities, for family and community guests. Informal, no formal rubric, a simple participation certificate.
No skill checks at this age, on purpose. Informal engagement across the twelve weeks and the weeks 11–12 show-and-tell carry the whole assessment story.
A sixth grader doesn't need a command line to understand that data has structure. A deck of index cards and a ball of yarn teaches the same lesson.
This is the one place the design deliberately breaks from the twelve-week, two-hour pattern shared by Tracks A and B, because forcing parity here would be the wrong call, not a convenient one. A five-year-old and a ten-year-old are not the same learner, so K–5 splits into two parallel programs run back to back in the same time slot: Little Coders (grades K–2) and Code Explorers (grades 3–5). Both run eight weeks, twice a year, shorter sessions than the older tracks, and both lean on real parent involvement in the room, not just at drop-off.
Robot Game: parent-child pairs give each other step-by-step instructions ("turn, walk, stop") before touching a screen. Path and maze games layer in repetition as an early, physical idea of a loop.
K–2 uses ScratchJr, picture-only blocks, no reading required. 3–5 uses Code.org's block-based editor in a teacher-managed class section, no individual student logins, built for COPPA compliance from the start. Both build toward a small animated story or simple game.
A real hands-on sorting-and-pattern game, framed as "how computers keep things organized." Deliberately not a watered-down MongoDB or Neo4j lesson. Real databases and real AI tools are held for Middle School, where the foundation actually supports them.
A Simon-Says-style conditionals game for both groups. Code Explorers adds light keyboard-game typing practice, familiarity only, no proficiency expectation, held back entirely for the K–2 group given fine-motor and reading limits.
Age-appropriate only. K–2 runs this as a short parent-child discussion. 3–5 gets a kid-led session plus a short parent portion.
Kids demo their ScratchJr or Scratch project to parents and family. Certificates, no rubric. Code Explorers closes with an explicit "see you in Middle School."
No skill checks, no quizzes, not even the informal tracking Track B uses. Participation and a completion certificate are the whole assessment story at this age, and that's deliberate, not a lower bar applied carelessly. The real operational cost: K–2 needs a parent in the room by design, and 3–5 needs at least one parent volunteer present for ratio and youth-protection reasons a solo founder can't meet alone, meaning this track can't launch on the same one-person model as Tracks A and B until that volunteer base exists.
A kindergartner doesn't need a database to understand that things can be sorted and grouped. A deck of picture cards and an adult sitting next to them teaches the same lesson, at the only pace that actually works at five years old.
None of this is invented from scratch, and none of it is copied wholesale from any one source either. It's adapted for a solo, volunteer-run program instead of a funded nonprofit with staff, drawing on four separate precedents.
Year Up's own structure, the one the founder went through, is the backbone of Track A. Genesys Works shows a youth-native version of the same idea works too. Code.org and CodeHS have already proven that once-a-week, after-school is a workable format for real school partnerships at scale, not just a workaround for one founder's limited time, and that's the scheduling spine both Track A and Track B are built on. The CSTA K-12 CS Standards are why the three tracks split where they split, rather than at some arbitrary age.
This is the long version. There's a short one too.
If you're a school district, a workforce board, a foundation, or someone who's run a program like this before and can tell me what I'm missing, I want to talk. This page exists so that conversation can start with the real details, not the elevator pitch.