The structural problem

Tightly coupled curriculum breaks
when agile teaching needs slack.

A teacher using agile teaching practices will, with reasonable frequency, need to spend an extra lesson on a concept that the class hasn't mastered. An exit ticket reveals that 16 out of 25 students cannot transfer the concept to a new context. Tomorrow's lesson needs to address this. But tomorrow's lesson is already planned as the introduction to the next topic — one that depends on the current one.

In a tightly coupled curriculum — where every lesson's content depends precisely on the previous one — this creates a cascade problem. One extra day on Concept A delays Concept B, which delays Concept C, which means Concept D arrives after the assessment point for which it was required. The teacher faces a choice between covering curriculum or teaching it. Most cover it.

Modular curriculum design solves this by absorbing the agile teacher's iteration needs at the unit level rather than the lesson level. The module's exit criteria remain fixed. The number of lessons to reach those criteria is flexible within a defined range. An extra lesson on a hard concept doesn't cascade because the module plan already accounts for it.

💡Modular vs sequential
Sequential curriculum: Lesson 1 → Lesson 2 → Lesson 3 (each depends on the previous). A delay at Lesson 1 delays every subsequent lesson.

Modular curriculum: Lessons 1–3 exist within a module with a shared exit criterion. An extra pass at any lesson is absorbed within the module's time allocation. The module boundary is the buffer.
Five design decisions

The choices that make a module
agile-compatible.

1
Define exit criteria as abilities, not lesson counts
The module is complete when students can do X — not when N lessons have been delivered

A module defined as 'photosynthesis: 6 lessons' ends when 6 lessons have been delivered, regardless of whether students understood it. A module defined as 'students can explain the relationship between light availability, chlorophyll, and glucose production in a novel plant scenario' ends when that ability is demonstrated. Exit criteria as abilities make iteration decisions rational: if students can't demonstrate the exit criterion, the module isn't finished.

How to write exit criteria as abilities
Use observable, transferable language: 'students can [verb that requires understanding, not recall] [specific concept] in [context that wasn't covered in the lesson].' The test: could a student answer this using only memory of what was said? If yes, it's a recall criterion, not an ability criterion.
2
Build flex lessons into the plan — not the gap
Every module should have 1–2 planned flexibility lessons

Planned flex lessons are lessons labelled at design time as 'consolidation if needed, extension if not' — taught if the formative data shows the class needs more time, skipped if students are ready to progress. This is different from improvised flex: the teacher hasn't scrambled to fill time, they are executing a planned contingency.

How to label flex lessons in the plan
'Lesson 5 of 7 (FLEX): consolidation if majority Q2 incorrect on Lesson 4 exit ticket; extension task if majority Q3 correct. Same exit ticket in either case.' The deployment criterion is written. The teacher makes a data-driven decision, not a judgment call.
3
Create alternative entry points for each core concept
Document 2–3 different explanations for the concepts that most reliably produce misconceptions

The alternative entry point solves the agile teacher's most time-consuming iteration task: when the standard explanation didn't work, what do I try instead? If the curriculum already documents a second and third approach — each approaching the concept from a different angle — the teacher's 20-minute iteration is reduced to a 3-minute selection.

What makes a good alternative entry point
A different analogy (not a different version of the same one). A different sequence (bottom-up instead of top-down). A different representation (concrete-to-abstract instead of abstract-to-concrete). The alternative must be structurally different, not just reworded.
4
Minimise prerequisites
Every prerequisite is a dependency — and dependencies create fragility

Each prerequisite the module requires is a potential cascade point: if students didn't fully master the prerequisite, the module is fragile from the start. Audit each module's prerequisites and ask: which are genuinely necessary, and which are assumptions that could be addressed within the module itself? The shorter the prerequisites list, the more resilient the module is to imperfect prior learning.

The prerequisite audit question
For each assumed prerequisite: 'If a student hasn't fully mastered this, can I build it into the module's opening lesson rather than assuming it?' If yes, move it inside the module. Genuine prerequisites — ones that can't be built in without restructuring the whole module — are worth documenting. Assumed ones are worth eliminating.
5
Define the module boundary clearly
Where does this module end and the next one begin?

The module boundary is the location where an iteration delay is absorbed rather than cascaded. It needs to be a genuine conceptual boundary — not an arbitrary lesson grouping. A clear boundary means: the next module can be taught without any lesson from this module being incomplete. This requires some redundancy in the design — the next module begins with a brief re-activation of relevant prior knowledge rather than assuming it.

The boundary test
Could a student who missed the final lesson of this module still engage productively with the first lesson of the next module? If yes, the boundary is sound. If no, the modules are not truly independent — the boundary is an arbitrary break in a sequential unit.
For curriculum creators

Why modular design earns better adoption
and better reviews.

A curriculum creator who builds tightly coupled sequential curriculum produces something that is difficult for schools to deploy, because schools teaching it will inevitably encounter the cascade problem. A creator who builds modular curriculum — with clear exit criteria, flex lessons, alternative entry points, and minimal prerequisites — produces something schools can deploy reliably across different teacher skill levels, class sizes, and prior attainment distributions.

This produces better adoption, better classroom outcomes, and better reviews. Modular design is not just good curriculum practice — it is the design choice that makes curriculum commercially durable in a marketplace where schools share reviews.