For nearly three decades, instructional designers built training the same way software teams once built applications: analyze the need, design the course, develop the content, implement it, then evaluate whether it worked — the well-known ADDIE model. It’s methodical, thorough, and has trained generations of instructional designers. It’s also, for a lot of modern L&D teams, too slow.
By the time a six-month ADDIE cycle produces a finished course, the business problem it was built to solve may have already changed. A compliance requirement gets updated. A product launches earlier than planned. A new hire cohort needs onboarding content next month, not next quarter. Software development faced the exact same problem in the early 2000s — rigid, sequential “waterfall” processes that couldn’t keep pace with how fast requirements actually changed — and the answer it found was agile methodology. Instructional design borrowed the same answer, and it’s reshaping how modern L&D teams actually build training.
Why Traditional Instructional Design Struggles to Keep Up
ADDIE isn’t a bad model — it’s a linear one, and linear models assume you know the full picture before you start building. Each phase depends on the previous phase being fully signed off before work begins on the next. That works well for large, stable projects with a fixed scope. It works far less well when:
- A subject matter expert changes their mind about content halfway through development
- Stakeholders don’t actually know what “done” looks like until they see a working prototype
- The business need itself shifts before the course is finished
- Feedback only surfaces at the very end, when it’s expensive to act on
The core problem is one of timing. In ADDIE, evaluation — the point where you actually learn whether the training works — comes last. If something’s fundamentally wrong with the approach, you find out after months of investment, not weeks.
Enter SAM: The Successive Approximation Model
The most established agile alternative in instructional design is the Successive Approximation Model (SAM), developed by instructional design pioneer Michael Allen and introduced in his book Leaving ADDIE for SAM: An Agile Model for Developing the Best Learning Experiences (Allen & Sites, 2012). Allen, founder of Allen Interactions and a longtime ADDIE practitioner himself, built SAM specifically because he saw how often linear processes produced technically complete but practically ineffective training.
SAM replaces ADDIE’s five sequential phases with a small number of repeating cycles: Preparation, Iterative Design, and Iterative Development. Rather than waiting until the end to test whether a course actually works, SAM teams build rough, low-fidelity prototypes almost immediately — sometimes within the first working session — and get them in front of stakeholders and even learners right away.
According to Allen Interactions, this process typically begins with what’s called a “Savvy Start” — an intensive collaborative session where designers, subject matter experts, and stakeholders build and critique quick prototypes together, rather than working from a static requirements document. As one Allen Interactions client, Stephanie Crowe (Senior Director, Global Learning & Development at Manhattan Associates), put it: “We witnessed months of what would’ve been wasted time and resources with ADDIE melt away.”
The logic is straightforward, and it maps closely to what agile software teams already knew: a rough prototype that’s wrong in an obvious way is far cheaper to fix than a finished product that’s wrong in a subtle one. According to eLearning Industry’s breakdown of the model, SAM’s iterative structure means that flaws surface — and get corrected — early and often, rather than accumulating unnoticed until a final evaluation phase that comes too late to matter.
How SAM Actually Works, Step by Step
1. Preparation. Rather than an exhaustive, months-long analysis phase, SAM’s preparation stage is deliberately brief — enough to understand the learners, the performance gap, and the general shape of the solution, without trying to nail down every detail up front.
2. The Savvy Start. A focused working session — sometimes a single day — where the design team rapidly sketches multiple rough prototype concepts. According to Thinkific’s guide to the model, the goal at this stage isn’t polish; it’s generating enough divergent ideas that the team can identify which direction is actually worth pursuing before investing real development time.
3. Iterative Design-Develop-Evaluate cycles. From here, the team moves through repeated short loops: build a slightly more refined version, test it with real stakeholders or sample learners, gather feedback, adjust, and repeat. According to The HowToo Blog’s guide to SAM, each cycle should be fast enough that a design flaw discovered in round two doesn’t feel like a wasted investment — because comparatively little time went into round one.
4. Convergence, not perfection on the first try. As the cycles continue, the strongest elements from various prototypes get combined and refined, while weaker ideas are dropped — described by instructional design consultant Devlin Peck as encouraging teams to ask “why shouldn’t we do this?” of every prototype, rather than defending a single early decision all the way to launch.
SAM vs. ADDIE: Not a Replacement, a Different Tool
It’s worth being precise here: SAM isn’t simply “ADDIE, but faster” — and it isn’t right for every project. As Valamis’s comparison of the two models notes, ADDIE’s structured, sequential approach still suits large, well-defined projects where stakeholders need clear sign-off gates at each stage, or where regulatory documentation requirements demand a linear audit trail. SAM, by contrast, tends to fit best where requirements are less certain up front, timelines are tight, or the content itself benefits from rapid learner feedback — new product training before a launch date, for instance, or a course responding to an urgent, fast-moving compliance change.
For a deeper look at how the traditional linear model works and where it still earns its place, see our companion guide: The ADDIE Model: A Comprehensive Guide to Instructional Design.
What This Looks Like for L&D Teams Building Training on an LMS
The theory matters less than the practical shift it enables. For an L&D team building training inside a Learning Management System, an agile approach changes the actual workflow:
- Launch a rough module fast, not a polished one slowly. A short, imperfect first version of an onboarding module, live in the LMS within days, generates real usage data and learner feedback that a six-month development cycle simply can’t produce before launch.
- Treat learner completion and assessment data as your feedback loop. Where SAM relies on stakeholder and learner input during prototyping, an LMS’s analytics — completion rates, quiz scores, time-on-module — become the ongoing feedback mechanism after launch, letting teams see almost immediately whether a course is landing the way it was designed to.
- Update in place rather than waiting for a full redesign cycle. A course built and hosted in an LMS can be revised incrementally — swap a confusing module, add a missing example, adjust a quiz question — without the all-or-nothing rework a printed manual or a monolithic classroom curriculum would require.
- Reduce the cost of being wrong. The single biggest advantage agile principles bring to instructional design is the same one they brought to software: catching a flawed approach after a small investment is far cheaper than catching it after a large one.
This is also where storytelling and structural creativity matter just as much as process — a fast iteration cycle still needs strong instructional content at its core. Our piece on The Role of Storytelling in Instructional Design covers how to make even a rapidly-prototyped module genuinely engaging rather than just quick.
Getting Started with Agile Instructional Design
Teams new to this approach don’t need to abandon ADDIE entirely to benefit from agile thinking. A few practical starting points:
- Run a Savvy-Start-style session before your next course build. Get subject matter experts, a manager stakeholder, and someone from the design team in a room (or a call) together, and sketch three rough approaches before committing to one.
- Build a low-fidelity prototype before writing final content. Even a simple slide outline or a rough script that a handful of real learners can react to will surface problems a requirements document never will.
- Shorten your feedback loop. If your current process only gets stakeholder or learner feedback at the very end, find one earlier point to insert a check-in — even an informal one.
- Use your LMS’s data as an ongoing feedback source, not just a compliance-tracking tool. Low completion rates or poor quiz scores on a specific module are exactly the kind of signal agile processes are built to act on quickly.
Conclusion
Agile methodologies didn’t stay confined to software development because the underlying insight was never really about code — it was about how to handle uncertainty and change without losing months of work to it. Instructional design faces exactly the same pressure: business needs shift, stakeholders don’t always know what they want until they see it, and waiting until the end of a long process to find out if something works is an expensive way to learn a lesson. The Successive Approximation Model gives L&D teams a proven, well-documented way to build training the way agile software teams build products — in small, testable steps, with real feedback shaping the outcome long before launch, not after it.
For organizations building this kind of iterative training workflow, an LMS that supports fast content updates, real-time learner analytics, and easy course revisions — rather than a rigid, hard-to-change course structure — is what actually makes an agile instructional design process practical at scale.
