OpenLiteracy Phase 2 · v1 MVP Student-Lesson Journey

Current vs. Proposed Logic — what we have, what we're proposing, what we need you to confirm

Date: 2026-05-20 From: Eric, Ryan, Beth (Ceridwen)

Scope: this doc covers the v1 MVP student-lesson journey only — a student enrolled, taking lessons in sequence. It does not cover catch-up lessons, multi-group flow, or the full educator surface. Those will be modeled separately.

For every diagram, the Current side shows what's in the Phase 1 code today. The Proposed side shows what we're recommending based on what your team described in the 5/04 intro and 5/11 kickoff. Where a proposal is grounded in a direct quote from your team, the source appears below the diagram in a green box so you can see exactly where it came from.

Add your team's responses in our shared Google Doc.
The Doc mirrors every section below — mark "Looks right" / "Needs revision," add changes, follow-ups, or context. You can comment, suggest, or type directly.
Open response Doc
Agreed — works as intended
Works but proposed for change
Gap or open question — needs your input
Proposed — new design under discussion

System overview — v1 MVP student-lesson journey

This is the agreed-upon v1 MVP journey for a student going through lessons — not the full picture (no catch-up lessons, no multi-group flow). Everything below already exists in code and is what we all agree on. No questions about this diagram — we are not asking you to review it. Sections 1–7 below are where we need your input.

Agreed — in code today
flowchart TD enroll([Student enrolled]) --> screener[Initial Phonics
Skills Survey] screener --> placement{Placement
decision} placement -->|All 13 skills passed| mastery[Skill 14 — Mastery] placement -->|Skill failed| place[Placed at failing
skill's first lesson] placement -->|Skill 1 fail + EL flag| elroots[EL / Roots track] place --> lesson[Run a lesson] lesson --> exitticket[Exit Ticket
at end of lesson] exitticket --> threshold{Score ≥ 70%?} threshold -->|Yes| advance[Advance to
next lesson] threshold -->|No| remed[Generate AI
remediation lesson] advance --> lesson remed --> remedlesson[Run remediation lesson] remedlesson --> remedticket[Exit Ticket on
remediation] remedticket --> remedthresh{Score ≥ 70%?} remedthresh -->|Yes| restore[Resume original
next lesson] remedthresh -->|No| nextattempt[Generate next
remediation attempt
a → b → c → ...] restore --> lesson nextattempt --> remedlesson classDef ok fill:#c9e0d2,stroke:#2d5a3d,color:#1a1a1a class enroll,placement,place,lesson,exitticket,threshold,advance,remed,remedlesson,remedticket,remedthresh,nextattempt,restore,mastery,elroots ok

The v1 MVP end-to-end flow. This is what the Phase 1 product does today. The sections that follow drill into each decision point and show what we're proposing to change.

1. Foundational decisions Asks 1.1

Score bands and lesson part-structure — these show up everywhere downstream.

1a. Score band routing — today (3 bands) vs. proposed (4 bands)

Current — in code today
flowchart TB s1[Lesson exit ticket
score out of 10] --> b1{Score?} b1 -->|9-10| pass[PASS
Advance] b1 -->|6-8| softpass[SOFT PASS
Advance with warmup] b1 -->|0-5| fail[FAIL
Stop, remediate] classDef ok fill:#c9e0d2,stroke:#2d5a3d classDef warn fill:#f4e4ce,stroke:#b87333 classDef gap fill:#efd9d9,stroke:#8b2c2c class pass ok class softpass warn class fail gap
Proposed — 4 bands
flowchart TB s2[Lesson exit ticket
score out of 10] --> b2{Score?} b2 -->|9-10| green[GREEN
Advance] b2 -->|8| ywarmup[YELLOW-warmup
Advance with warmup] b2 -->|6-7| ystay[YELLOW-stay
Stay & remediate] b2 -->|0-5| red[RED
Drop down to
previous lesson] classDef ok fill:#c9e0d2,stroke:#2d5a3d classDef new fill:#e4dff0,stroke:#6b5b95 classDef gap fill:#efd9d9,stroke:#8b2c2c class green ok class ywarmup,ystay new class red gap

The big difference: the proposed system splits the middle band into two — a score of 8 advances with a warmup attached; a 6 or 7 stays in the lesson and remediates. RED becomes "drop down to the previous lesson" rather than just stopping. This 4-band split is our proposal for you to confirm or revise.

1b. Lesson structure — 6 parts today vs. 4 proposed

Current — 6 parts in database
flowchart TB p1[Warm-up] --> p2[Language Lab
teaching slides] p2 --> p3[Guided practice] p3 --> p4[Writing /
dictation] p4 --> p5[Fluency stack] p5 --> p6[Passage] classDef keep fill:#c9e0d2,stroke:#2d5a3d classDef drop fill:#efd9d9,stroke:#8b2c2c class p1,p2,p3,p6 keep class p4,p5 drop
Proposed — 4 parts
flowchart TB q1[Warm-up] --> q2[Language Lab
teaching slides] q2 --> q3[Guided practice] q3 --> q4[Passage] classDef new fill:#e4dff0,stroke:#6b5b95 class q1,q2,q3,q4 new

Our assumption is writing/dictation and fluency stack get dropped or merged into the other parts. Confirm in N.2.

Where this came from
"We're only going to have four parts to each lesson, not six." Sarah Scott Frank — 5/04 intro meeting, 9:30

2. Initial Phonics Skills Survey Asks 1.2

The placement screener — once when a student enrolls. Determines what skill they start on.

2a. Screener flow — today (word list only) vs. proposed (sentence + word list)

Current — in code today
flowchart TD start([Start screener]) --> loadlist[Load 10-word list
for current skill] loadlist --> show[Display words to student] show --> teacher[Teacher scores
each word] teacher --> tally[Tally correct
0-10] tally --> evaluate{Score?} evaluate -->|9-10| pass[Green — pass] evaluate -->|6-8| soft[Yellow — soft pass] evaluate -->|0-5| fail[Red — fail] pass --> nextskill{Final skill?} soft --> nextskill fail --> nextskill nextskill -->|No| advance[Move to next skill] nextskill -->|Yes| done[All skills done] advance --> loadlist done --> place[Apply placement decision] classDef warn fill:#f4e4ce,stroke:#b87333 class start,loadlist,show,teacher,tally,evaluate,pass,soft,fail,nextskill,advance,done,place warn
Proposed — sentence first, then word list
flowchart TD startp([Start screener at CVC]) --> sentence[Read 1-2 sentences
containing 5 target words
for this skill] sentence --> sscore{Got all 5
target words?} sscore -->|Yes — 100%| sgreen[Green — pass skill
move to next skill] sscore -->|No| wordlist[Read 10-word list
5 real + 5 nonsense] wordlist --> wscore{Word-list score?} wscore -->|9-10| wgreen[Green — pass] wscore -->|6-8| wyellow[Yellow — partial,
some target patterns missed] wscore -->|1-5| wred[Red — fail] wscore -->|0| wzero[Zero — flag for discontinue rule] sgreen --> nextp{Final skill?} wgreen --> nextp wyellow --> nextp wred --> nextp wzero --> nextp nextp -->|No| advancep[Move to next skill] nextp -->|Yes| donep[Apply placement decision] advancep --> sentence classDef new fill:#e4dff0,stroke:#6b5b95 classDef ok fill:#c9e0d2,stroke:#2d5a3d class startp,sentence,sscore,wordlist,wscore,wyellow,wred,wzero,nextp,advancep,donep new class sgreen,wgreen ok

The proposed change adds a sentence-level check first, so strong readers don't have to grind through 10 words on every skill. The student only reads the word list if they miss a target word in the sentence.

Where this came from
"We want all students to start with this skill, CVC… And what we want to shift from is from reading words to reading a sentence. So every skill will start with reading one sentence, and then based on how they perform on that sentence, which will have target words within it, they would then move into needing to read a word list." Rebecca Patterson — 5/04 intro meeting, 18:06
"It will be 100% for the sentence to be like, okay, that skill's green and we're not going to worry about it, we're going to move on. But if they get even one of the five target words wrong, then they would move to the word list, and the word list is going to be like 90% then becomes green." Rebecca Patterson — 5/04 intro meeting, 19:24
"The sentence piece is so that those more advanced readers are just reading like 10 sentences, and then they're done for the whole assessment, and they're going to get started with that learning at their level." Greta Phillips Kendall — 5/04 intro meeting, 19:48
Both flows end with "Apply placement decision" — but we don't have a written rule for how a student's mixed screener results combine into one starting placement. For example, a student gets green on skills 1–3, yellow on skill 4, red on skill 5, green on skill 6. Where do they start?
  • Place at the first red they hit (skill 5)?
  • Place at the first non-green (skill 4, with yellow context)?
  • Place at the highest skill they passed + back-fill the yellows / reds as catch-up later?
We need your team's rule. This is the question that decides what a fresh student's pathway actually looks like on Day 1.
Current — in code today
flowchart TB t1[Student fails one skill
score 0-5 on word list] --> t2[STOP screener
place student at
that skill's lesson 1] classDef warn fill:#f4e4ce,stroke:#b87333 class t1,t2 warn
Proposed — zero-zero, two in a row
flowchart TB n1[Student gets zero on the sentence
AND zero on the word list] --> n2[Continue to the next skill] n2 --> n3{Same zero-zero result
on the next skill?} n3 -->|Yes — two consecutive zero-zeros| n4[STOP screener
place student] n3 -->|No — any non-zero result| n5[Continue screening normally] classDef new fill:#e4dff0,stroke:#6b5b95 class n1,n2,n3,n4,n5 new

Today's screener stops on the first skill where a student scores 0–5. The proposed rule keeps the student going through one more skill if they bottom out completely — only stopping after two consecutive zero-zero results. This is our interpretation of what Rebecca described at the 5/04 kickoff (quotes below). The intent we picked up: catch students who genuinely can't read at the level we started them on, while still giving them a chance to demonstrate strength in a higher skill they might unexpectedly know.

Where this came from
"They would go on to do the digraph sentence and so on until they meet that discontinue criteria, which is two in a row… That's zero sentence, zero words." Rebecca Patterson — 5/04 intro meeting, 27:00
"We don't want to stop if they're red, because we could have a lot of reds, but they're still reading some words. We want to stop if they're like zero, zero, like totally bottom-out and out, just for the discontinuity." Rebecca Patterson — 5/04 intro meeting, 28:13
"We were a little crayon initially, but the zero, zero is what we want." Rebecca Patterson — 5/04 intro meeting, 1:15:15
Does the diagram above match what you meant by the zero-zero rule, or would you describe it differently? Specifically:
  • Is "zero on the sentence AND zero on the word list" the right definition of a "zero-zero"? Or is it any combination of zero-sentence + low-word-list?
  • Does the rule reset if the student gets any non-zero result, or does it accumulate across non-consecutive skills?
  • Once stopped, where is the student placed — the last skill they got any credit on, or somewhere else?

3. Lesson structure & time variants Asks 1.3

How a single lesson gets composed for different session lengths. Key clarification from OL (5/20): session duration is set when a group is created or in group settings, not chosen at lesson start. Once a group has a duration, every lesson for that group uses the matching template.

3a. Proposed: duration is set at group setup, not at lesson start

Proposed — under discussion
flowchart TD create([Educator creates group
OR edits group settings]) --> set[Set session duration
15 / 25 / 30 min] set --> store[(Stored on group
used for all lessons
until changed in settings)] store --> later[Later: Educator starts
a lesson with this group] later --> load{Load template
matching group's duration} load -->|15 min| short15[15-min template
contents TBD] load -->|25 min| standard25[25-min standard template
= existing 4-part lesson + exit ticket] load -->|30 min| long30[30-min template
contents TBD] short15 --> deliver[Deliver lesson] standard25 --> deliver long30 --> deliver classDef new fill:#e4dff0,stroke:#6b5b95 classDef ok fill:#c9e0d2,stroke:#2d5a3d classDef gap fill:#efd9d9,stroke:#8b2c2c class create,set,store,later,load,deliver new class standard25 ok class short15,long30 gap

Duration is a property of the group, not the lesson. Teacher picks it at intake (when assembling the group), can edit it later in group settings. Lessons then load the matching template automatically.

Where this came from
"We talked about, part of the scope is like, you could adjust the time. So you could have a 15-minute lesson. What is in a 15-minute lesson? Is it that we're splitting a 30-minute lesson in half and it becomes two days?" Sarah Scott Frank — 5/04 intro meeting, 9:30
"System recommended will not work. Schools have schedules. Recommended that the duration is set as part of intake — when they are specifying the schedule, set the duration of a lesson as part of intake." Your team's response to our Round 2 questions on session duration
This is the question Sarah raised at the 5/04 kickoff and we still need an answer: what content is in the 15-minute and 30-minute lesson templates? Only the 25-minute standard (4-part + exit ticket) exists in content today. If 15 and 30 are wanted, we need your team to define what's cut from 15 and what's added to 30.

4. Within-lesson content Asks 1.4

Warm-ups and lesson skip logic. We think of these at the group level, not individual student — a group can be as small as 1.

4a. Warm-up word selection — today (generic) vs. proposed (per-pattern matrix)

Current — generic warmups
flowchart TB t1[Start lesson] --> t2[Pull warm-up content
from lesson record] t2 --> t3[Generic warmup
same for every group] classDef warn fill:#f4e4ce,stroke:#b87333 class t1,t2,t3 warn
Proposed — per-pattern matrix
flowchart TB n1[Start lesson] --> n2[Look up group's
per-pattern matrix] n2 --> n3{For each word-pattern
in this skill} n3 -->|Mastered ✓| skip[Skip — don't warm up
what they know] n3 -->|Not yet ✗| n4[Pull warm-up words
for that pattern] n4 --> n5[Targeted warmup
different per group] classDef new fill:#e4dff0,stroke:#6b5b95 classDef ok fill:#c9e0d2,stroke:#2d5a3d class n1,n2,n3,n4,n5 new class skip ok

What is a "per-pattern matrix"? A grid where the rows are skills and the columns are word-patterns within each skill. Each cell tracks whether the group has demonstrated mastery on that specific pattern (green) or not yet (red). The warmup pulls from the red cells.

Where this came from
"You could serve up a warm-up that's really targeted towards actually one kid in the group, and you could serve up two practice activities that's targeted towards the vast majority of them and this other outlier… you could somehow notate for the teacher, 'this practice makes sure that this is really served up to John'… this group has mixed needs." Sarah Scott Frank — 5/11 Sprint 1 Kickoff, 25:30
"You could imagine building a different database that was more of a matrix… you just had both a horizontal and a vertical that you were going from." Sarah Scott Frank — 5/11 Sprint 1 Kickoff, 8:43

Implementation note: the per-pattern matrix is new structure. It needs storage (matrix per group), a definition of how cells move to "mastered," and a word-pattern source list. We have a question open on whether your team can supply the word-pattern source list (C.3).

How does a cell in the matrix flip from "not yet" to "mastered"? What signal — exit ticket score on that word? Progress monitor result? Some combination?

4b. Skip logic for already-known patterns — gap today

Current — no skip logic
flowchart TB t1[Lesson 28 — W words
in sequence] --> t2[Group takes lesson 28
even if they already
know W from screener] classDef gap fill:#efd9d9,stroke:#8b2c2c class t1,t2 gap
Proposed — mastery-driven skip
flowchart TB n1[Approach lesson 28] --> check{Per-pattern matrix —
has group mastered W?} check -->|Yes| n2[Skip lesson 28
go to lesson 29] check -->|No| n3[Run lesson 28 normally] classDef new fill:#e4dff0,stroke:#6b5b95 class n1,check,n2,n3 new

Today's product runs lessons in strict sequence — a student takes lesson 28 even if they already demonstrated mastery of W in the screener. The proposed change uses the per-pattern matrix to skip lessons whose target is already mastered.

Where this came from
"If they know 10 letters, can we skip some of those letter lessons because they know J and W and T and M and S and P? And so maybe we can focus on it… letter level and at CVC, like if you know short E and short A, but you don't know short I and short O, then we can really focus our attention on I and short I and short O." Sarah Scott Frank — 5/04 intro meeting, 38:27
"If you think of this instructional time as gold, you have this amazing opportunity to move kids really fast. If they already know the skill, the worst use of a kid's time is when they're just marching through lessons that are too easy." Sarah Scott Frank — 5/04 intro meeting, 40:01
Does every lesson carry a mastery target — i.e., the specific pattern that lesson teaches and that we'd check against the matrix? For example, is lesson 28's target the pattern "W"? Without a per-lesson target, the system can't decide whether to skip.

5. Skill transition & progress monitoring Asks 1.5

When is a group ready to move from one skill to the next? What triggers a formal "progress monitor" check?

5a. Today's lesson progression — purely sequential

Current — in code today
flowchart LR l1[Lesson 1] --> l2[Lesson 2] --> l3[Lesson 3] --> ldots[...] --> lN[Lesson N] exitn[Each lesson's exit ticket] --> th{Score ≥ 70%?} th -->|Yes| advance[Advance to
next lesson_number] th -->|No| remediate[Trigger remediation] classDef warn fill:#f4e4ce,stroke:#b87333 class l1,l2,l3,ldots,lN,exitn,th,advance warn classDef gap fill:#efd9d9,stroke:#8b2c2c class remediate gap

Today's progression is "next lesson_number = current + 1." No distinct "skill transition" event, no progress monitor as a separate concept.

5b. Proposed: progress monitor as a distinct event with explicit triggers

Proposed — under discussion
flowchart TD ongoing[Group doing lessons
in current skill] --> trigger{Which trigger fires?} trigger -->|3 consecutive exit tickets at 80% or higher| soft["Soft prompt — Run a progress monitor?"] trigger -->|3 consecutive exit tickets at 90% or higher| hard["Hard prompt — Must run progress monitor before continuing"] trigger -->|Teacher manually opts in| optin[Teacher-initiated PM] trigger -->|All lessons in skill done| auto[Auto-triggered PM] trigger -->|MTSS prep mode| mtss[Specialist-initiated PM] soft --> pm[Progress Monitor
10 fresh words] hard --> pm optin --> pm auto --> pm mtss --> pm pm --> result{Result?} result -->|Green| advance[Advance to next skill] result -->|Yellow / Red| stay[Stay in skill
or drop down] classDef new fill:#e4dff0,stroke:#6b5b95 classDef ok fill:#c9e0d2,stroke:#2d5a3d class ongoing,trigger,soft,hard,optin,auto,mtss,pm,result new class advance,stay ok

E.8 asks you to confirm the trigger conditions and adjust the thresholds. The triggers below are drawn from what your team described in the 5/04 intro.

Where this came from
"Ways that it can be triggered. So it would be like a different outside of the lesson. We wanted like a button that's always available, progress monitor. So then that's educator choice. I want to see. I have a meeting coming up. I think they're ready. Whatever the use case is. Or that 90%, you've excelled through three lessons in the skill bucket. You don't have a choice. Let's see if they're ready." Rebecca Patterson — 5/04 intro meeting, 56:59
"I think we said 80% would move forward." Rebecca Patterson — 5/04 intro meeting, 56:46
"The progress monitor is going to be reading 10 words to kind of exit the skill. So it's like the exit ticket, but it's going to be a new list… five real, five nonsense that encompasses all of the skills in that skill bucket. The progress monitor hasn't been built yet." Rebecca Patterson — 5/04 intro meeting, 55:13

5c. The Yellow-to-Green question

Proposed — options for OL to pick
flowchart LR state1[Group gets 8 on
a skill — Yellow-warmup] --> adv[Advances to next skill
with warmup attached] adv --> drift[Original skill stays
Yellow on dashboard] drift --> q{When does it turn
Green on dashboard?} q -->|Option A| greenpm[On next progress monitor
if Green there] q -->|Option B| greenpre[On next pre-assessment
if 9-10] q -->|Option C| greenauto[Automatically after
N successful lessons
in next skill] classDef new fill:#e4dff0,stroke:#6b5b95 classDef gap fill:#efd9d9,stroke:#8b2c2c class state1,adv new class drift gap class q,greenpm,greenpre,greenauto new

B.8 — without a "turn Green" rule, Yellow skills accumulate and never resolve. Our recommendation is Option A (next progress monitor clears it), which matches what your team described at kickoff.

Where this came from
"Think about those skills in the initial assessment and some were yellow, some were red — the progress monitor is going to be the only thing that now makes it green. Now that's green. And the idea is to obviously by the end of the year have as many green as possible. So it takes a skill they didn't previously pass, makes it green, shows that they're ready to move on." Rebecca Patterson — 5/04 intro meeting, 57:31

6. Remediation Asks 1.6

Your team identified remediation as the area that most needs redesign. This section walks through the current behavior and what we're proposing.

Where this came from
"I think, on the back end, our logic isn't totally right. Our remediation is weak." Sarah Scott Frank — 5/04 intro meeting, 9:30
"The hard part is the remediation because, what is the AI tool going to generate to remediate for the students?" Rebecca Patterson — 5/04 intro meeting, 12:20

6a. Today's remediation loop

Current — in code today
flowchart TD gen[AI remediation triggered
OpenAI call from browser] --> create[Create remediation_lessons row
attempt = 'a'] create --> deliver[Deliver remediation lesson] deliver --> ret[Exit ticket on remediation] ret --> rth{Score ≥ 70%?} rth -->|Yes| restore[Mark 'passed'
restore original next_lesson] rth -->|No| next[Mark 'superseded'
generate attempt 'b'] next --> deliver loop[No cap on attempts
could be infinite] -.- next classDef warn fill:#f4e4ce,stroke:#b87333 classDef gap fill:#efd9d9,stroke:#8b2c2c class deliver,ret,rth warn class gen,create,restore,next gap class loop gap

Two gaps: (1) no upper limit on attempts — group can theoretically be stuck forever, (2) every retry generates a brand-new AI lesson; no "retry same lesson with new practice" pathway.

6b. Proposed: tiered remediation + bounded retries

Proposed — under discussion
flowchart TD exit[Exit ticket failed] --> score{What score band?} score -->|7-8| intensive[Skill-intensive remediation
shorter, targeted
see open question below] score -->|0-6| standard[Standard remediation
fuller re-teach] intensive --> attempt[Run remediation lesson] standard --> attempt attempt --> check{Pass?} check -->|Yes| advance[Restore original pathway] check -->|No - attempt 1 failed| retry1[Same lesson — reshuffled
new practice words
not a fresh AI lesson] retry1 --> check2{Pass?} check2 -->|Yes| advance check2 -->|No - attempt 2 failed| retry2[New AI-generated lesson
different shape, same skill] retry2 --> check3{Pass?} check3 -->|Yes| advance check3 -->|No - attempt 3 failed| escalate[Alert learning specialist
group stuck on this skill] classDef new fill:#e4dff0,stroke:#6b5b95 classDef ok fill:#c9e0d2,stroke:#2d5a3d class exit,score,intensive,standard,attempt,check,retry1,check2,retry2,check3,escalate new class advance ok

Two changes vs. today: (1) tier the remediation by how badly the group missed; (2) cap the number of attempts before alerting a specialist; (3) on the first retry, reshuffle the same lesson (different practice words, same teaching) rather than generate a fresh AI lesson — only generate new on attempt 2. Please adjust the tier thresholds and the cap.

What should "skill-intensive remediation" be? It needs to be defined as a content type. Today we don't have short variants of skills in the lesson library, so if you want a distinct 7–8 tier, we need your team to describe what content lives there.

6c. When does the system reuse a passage vs. generate a new one?

Proposed — under discussion
flowchart LR fail[Group fails
passage exit ticket] --> attempt{Which attempt?} attempt -->|1st retry| same[Same passage
fluency by repetition
per Sarah's input] attempt -->|2nd+ retry| different[New passage
similar pattern,
fresh content] classDef new fill:#e4dff0,stroke:#6b5b95 class fail,attempt,same,different new

D.7 — repeated exposure to the same passage is valuable for students who are stuck, but at some point a fresh passage helps more than another repetition. The proposed rule above is "same passage on the first retry, new passage from the second retry on." Please confirm or adjust the cutover point.

Where this came from
"They can't read the passage. They can't access the passage that we gave them. So we want them to read that multiple times. So I think new words is important, but I think the same passage would be valuable for a lot of students that are stuck." Rebecca Patterson — 5/04 intro meeting, 1:03:00
"You could take the passage and have them read two sentences fluently, kind of dial it back. So you could use the existing passage to generate a smaller targeted practice out of it." Sarah Scott Frank — 5/04 intro meeting, 1:04:19
"Most of the time when the lessons get too difficult too quickly, especially in that CVC bucket, is because of the passage. Our passages start at lesson 12 and the kids that aren't ready to read a passage can't read a passage. So repeated exposure is definitely a good thing." Rebecca Patterson — 5/04 intro meeting, 1:04:38
Behind this is the larger source-of-passages question — should the system AI-generate passages, pull from a pre-approved passage bank your team maintains, or let the teacher choose at the moment of retry? We need a direction on this before the retry logic can be finalized.

7. Group sessions Asks 1.7

The decision engine treats the group as the unit it reasons about — a group can be as small as one student. 1:1 tutoring is just a group of size 1, not a separate mode.

Where this came from
"We're building a tool that's for a group, a group that could be as small as one for one-to-one tutoring or, you know, up to four or five or six kids." Sarah Scott Frank — 5/04 intro meeting, 4:06
"This is a tool that's for groups, but your group can be as small as one. We specialize in one-to-one right now. What we do, we dabble in groups. And so it has to accommodate both." Sarah Scott Frank — 5/11 Sprint 1 Kickoff, 23:12

7a. Today's group logic — group moves at the slowest student's pace

Current — in code today
flowchart TD group([Group of 1+ students]) --> identify[Identify lowest-performing
student in the group] identify --> pace[Group moves at
that student's pace] pace --> lesson[Run group lesson
at lowest student's level] lesson --> teacher[Teacher can pull
furthest-behind student
into a personal lesson
while group continues] teacher --> back[Student rejoins group] back --> pace classDef warn fill:#f4e4ce,stroke:#b87333 class group,identify,pace,lesson,teacher,back warn

Each student has their own pathway underneath, but the group lesson stays at the slowest student's level. We're including this diagram so you can react to the actual behavior — is this the right model, or is there a better one your team has in mind?

Where this came from
"You really have to sort of go with what's best for the group, knowing there will be outliers. And the reality is that in lots of cases, the child can't move, like that's the third grade group… So you have to sort of teach to the mean and create a logic model that serves up something that's going to move a majority of kids." Sarah Scott Frank — 5/11 Sprint 1 Kickoff, 25:30
Is "match the slowest student's pace" the right rule, or is there a different group-pacing model your team prefers?

7b. The exit-ticket time problem at group scale

Current — every student reads every word
flowchart TB t1[Group of N students] --> t2[Every student reads
every exit ticket word] t2 --> t3[Takes the whole lesson
for larger groups] classDef warn fill:#f4e4ce,stroke:#b87333 class t1,t2,t3 warn

This is the pain we need to solve. We don't have a confident proposal yet — your team's input on the next iteration of group exit tickets would be valuable.

Where this came from
"I watched a lesson… there were seven kids in the group, maybe more. And every single, they sat there while every single student read aloud every single word on the slot for like nine minutes. It was a third of the lesson." Sarah Scott Frank — 5/04 intro meeting, 45:20
"If you have one, you can do X. If you have three, you can do X. If you have nine, you certainly cannot have nine children reading word lists of ten… So that becomes the whole lesson. That's dumb. So you can have a branching structure, or you can build a logic model that accounts for group size where something different happens for one child or even two children versus five." Sarah Scott Frank — 5/11 Sprint 1 Kickoff, 32:44
"Depending on the group size, there could be one at-bat per student, two at-bats per student, ideally three at-bats. Then they can at least take that and say, this group as a whole got 80% accuracy." Rebecca Patterson — 5/04 intro meeting, 34:44
How would you like to handle group exit tickets at scale? Options to consider — (1) keep every-student-reads-every-word but shorten the ticket, (2) rotate which students answer each item across sessions, (3) one student demonstrates per item with the rest signaling along, (4) something else. Your team's preference here will shape the rest of the group logic.

7c. Group remediation when not every student passes

Proposed — needs your input
flowchart TD ticket[Exit ticket taken
group result computed] --> some{How many in the group failed?} some -->|0 failed| advance[Advance whole group] some -->|Some failed| partial[Open question:
whole group remediates,
only those who failed remediate,
or split the group?] some -->|Most failed| groupremed[Group-level remediation] classDef new fill:#e4dff0,stroke:#6b5b95 classDef ok fill:#c9e0d2,stroke:#2d5a3d class ticket,some,groupremed,partial new class advance ok

We don't have firm thresholds for "most failed" yet — the right number depends on how you want the group to stay together vs. split.

When part of a group fails the exit ticket, what's the right rule — (a) whole group remediates together regardless of mix, (b) whole group advances if a majority passes, (c) split the group with some advancing and some remediating, or (d) something else? And what's the threshold percentage that triggers remediation?

How to use this doc alongside the question list

Each section maps to a section of the question list we sent over:

When you're answering a question, look at the diagram to see exactly what part of the system your answer is shaping. The green "Where this came from" boxes under each diagram show the verbatim quote from your team that the proposal is based on — click the Fathom timestamp links to jump straight to that moment in the recording. Click any diagram to expand it to fill the screen for easier reading.

Done reading? Open the shared Doc to add your responses to each section.
Open response Doc