The Successive Approximation Model (SAM): A Complete Guide

SAM, the Successive Approximation Model, is an iterative instructional design process created by Michael Allen. Instead of perfecting a design on paper and then building it once, SAM gets a rough working version in front of stakeholders early and improves it through short, repeated cycles of design, prototyping, and review.

If you're new to how instructional design works, this model is one of the two process frameworks you'll hear about constantly. The other is the ADDIE model, and this guide covers how the two compare, when each one is the better fit, and what I actually use on my own projects.

What Is the SAM Model of Instructional Design?

SAM is an agile-style instructional design process that replaces linear, waterfall-style development with repeated loops of designing, prototyping, and reviewing. The name comes from behavioral psychology: "successive approximation" is the shaping technique of rewarding small steps toward a target behavior. Applied to course development, it means you approach a great learning experience through many small improvements rather than one giant, supposedly perfect step.

Michael Allen introduced the model in Leaving ADDIE for SAM: An Agile Model for Developing the Best Learning Experiences, written with Richard Sites and published by ASTD Press (now ATD) in 2012. The book positions SAM as a response to the frustrations of waterfall development: long analysis phases, heavy documents nobody reads, and stakeholders who only see the product when it's too late to change it.

SAM rests on three beliefs:

1. No eLearning product is ever perfect. Chasing perfection before launch wastes time you could spend improving a live product.
2. Functional prototypes beat storyboards. Stakeholders react to something they can click through far more usefully than they react to a text document describing it.
3. Quick, disposable prototypes encourage creativity. When a prototype took two hours instead of two weeks, nobody is afraid to throw it away and try a better idea.

I walk through the whole model, including the phases and the Savvy Start, in this video:

What Are the Three Phases of SAM?

SAM has three phases: Preparation, Iterative Design, and Iterative Development. The second and third phases are loops, not steps, which is what separates SAM from a sequential process.

Phase	Key activities	Outputs
1. Preparation	Gather background on learners, goals, and constraints; hold the Savvy Start kickoff	Project foundation, first design ideas, rough throwaway prototypes
2. Iterative Design	Rotate through design, prototype, and review; plan the project	Refined prototypes, project plan, lightweight design documentation
3. Iterative Development	Build, implement, and evaluate in cycles	Design proof, then alpha, beta, and gold versions

Phase 1: Preparation

Preparation is quick and deliberate background gathering: who the learners are, what the performance goals are, and what constraints you're working within. SAM keeps this phase short on purpose, because every assumption you make here gets re-checked in later cycles anyway.

The phase culminates in the Savvy Start, a collaborative kickoff session with stakeholders, subject matter experts, and the design team. According to Allen Interactions, the firm Michael Allen founded, a Savvy Start typically runs one to two days. The group defines how success will be measured, brainstorms design directions, and even sketches rough prototypes together. It's also the natural moment to draft your first pass at learning objectives, knowing they'll get sharpened in later cycles.

Phase 2: Iterative Design

Iterative Design is a loop: design a piece, prototype it, review it with stakeholders, and repeat. The prototypes are intentionally rough and disposable. Their job is to build consensus fast, not to look polished. When a stakeholder sees three quick treatments of the same interaction, the "what do you actually want?" debate resolves itself in one meeting instead of five email threads.

Project planning happens here too. Design documentation still exists in SAM, it's just lighter and evolves alongside the prototypes rather than getting locked before development begins. If you want to see what that documentation typically covers, here's how to create an instructional design document.

Phase 3: Iterative Development

Iterative Development moves the winning design into production through a series of named versions, with evaluation feeding every cycle. Per Allen Interactions' phase definitions:

• Design proof: a working sample that verifies the design and functionality before you produce full content.
• Alpha: the complete version with all content in place, ready for detailed review.
• Beta: the alpha with identified errors and omissions corrected.
• Gold: the release version, reached when the beta review surfaces no further problems.

What Is the Difference Between SAM1 and SAM2?

SAM1 is the simplified version: a single repeating cycle of evaluate, design, and develop, suited to small teams and small projects. SAM2 is the extended version with all three phases and formal milestones, built for larger or riskier projects with more stakeholders.

Dimension	SAM1	SAM2
Cycle structure	One repeating loop: evaluate, design, develop	Three phases (Preparation, Iterative Design, Iterative Development), each with its own loops
Milestones	Few; iterate until the product is good enough or the deadline arrives	Formal: Savvy Start, design proof, alpha, beta, gold
Best for	Small teams, simple projects, low political risk	Bigger budgets, more stakeholders, higher-stakes deliverables
Documentation and ceremony	Minimal	Moderate; project planning and additional design work are built in

A useful way to think about it: SAM1 is what a two-person team does instinctively when they build, show, and fix. SAM2 adds just enough structure that a ten-person project with an executive sponsor doesn't fall apart.

SAM vs. ADDIE: What Is the Difference?

ADDIE moves through five phases in sequence and perfects the design before anything gets built. SAM builds a rough working version almost immediately and improves it through repeated cycles. That difference in when you first see a working product drives everything else.

Dimension	ADDIE	SAM
Structure	Five sequential phases: Analyze, Design, Develop, Implement, Evaluate	Three phases, with design and development running as loops
First working product	Late, after design is approved	Days into the project, as rough prototypes
Stakeholder involvement	Concentrated at phase sign-offs	Continuous; a review sits inside every cycle
Documentation	Heavy and upfront	Light, evolving with the product
Best-fit projects	Compliance-heavy work, stable requirements, teams that need audit trails	Fuzzy requirements, available stakeholders, novel or interactive deliverables
Risk profile	You may build the wrong thing and find out late	Iteration can sprawl without exit criteria

The 2012 framing was "leave ADDIE for SAM." That's not how most teams operate now. The working consensus is to hybridize: ADDIE-style upfront analysis where the problem is unclear, SAM-style iterative build once you're producing something. ADDIE is still best in compliance-heavy, documentation-first environments, which I cover in the ADDIE guide. Treat the two models as a toolkit, not rival religions.

When Should You Use SAM?

Use SAM when stakeholders can give fast feedback, requirements are still fuzzy, and a working prototype will settle debates faster than a document. In practice, SAM fits when most of these are true:

• Your reviewers are available. SMEs and stakeholders can turn feedback around in days, not weeks. This is the make-or-break condition.
• Nobody can articulate exactly what they want. People recognize the right solution when they see it far more reliably than they can describe it in advance.
• The timeline is tight. You need something usable soon, and a "good enough now, better next cycle" release beats a perfect product that ships late.
• The deliverable is interactive or novel. Simulations, scenarios, and branching experiences lose everything in a text description. A prototype is the only way to review them.
• You need consensus. Opinionated stakeholders align faster around a clickable prototype than around a 40-page design document.

One caveat on the evidence base: SAM has far less research weight behind it than ADDIE. There is peer-reviewed application work, such as a 2019 study by Jung, Kim, Lee, and Shin in the International Journal on E-Learning that documented a full SAM build through alpha, beta, and gold and found learners rated the final version more favorably than a traditional eLearning environment. But you're mostly relying on practitioner experience, not a deep research literature.

When Does SAM Fail?

SAM fails when stakeholders can't review quickly, when iteration has no exit criteria, and when the project demands heavy documentation up front. Here's my experience of when SAM fails:

• Slow or absent stakeholders kill it. SAM's driving force is the review cycle. If your SME takes three weeks to respond, every iteration becomes dead time, and you'd have been better off writing one thorough document and getting one thorough sign-off.
• Iteration without exit criteria becomes scope creep. "One more round" is seductive. Without timeboxes and a definition of what done looks like, SAM turns into an infinite loop that burns the budget on polish nobody asked for.
• Compliance projects punish it. When regulators or legal teams need to sign off on exact content before development, the sign-off document is the deliverable. A disposable prototype has no legal standing.
• Fixed-bid budgets fight it. Open-ended cycles and a fixed price are natural enemies. If the contract locks scope and cost, either cap the number of iterations in writing or use a more sequential process.

Not sure which way your project points? This quick checker maps your stakeholder availability, deadline, and documentation burden to SAM1, SAM2, ADDIE, or a hybrid:

Do Instructional Designers Actually Use SAM?

Yes, but rarely by the book. Most working teams blend SAM-style prototyping with ADDIE-style analysis, and job postings tend to name both models as shorthand for "you know how follow a process & apply ID models."

That's true for me too. I don't run SAM by the book, but I use its prototyping and iterative nature heavily on my projects. My philosophy is to get a live, functional prototype in front of SMEs and stakeholders as soon as possible. I used to present text-based storyboards, but with how quickly we can build prototypes now with tools like Claude Code, functional prototypes are the better option. If you have the skillset to build them fast, at least.

Here's what that looks like on a real project. I'm currently working with a Fortune 500 retailer on a software simulation that incorporates AI-powered roleplay, so learners practice navigating the software while talking to customers. The loop is pure SAM: I meet with subject matter experts to discuss requirements, build a prototype with AI, then review it together and repeat. Each review round pulls the build closer to production: the software sim starts behaving more like the real software, the visuals come on-brand, and we tune the AI customer to be more or less difficult based on what the SMEs see.

When it comes to hiring, SAM has been more popular in tech space historically (due to its agile origins). These days, there is less focus on ID models in hiring and more focus on which AI models you're using. But as long as you can go into an interview confidently and describe what you prototyped, who reviewed it, and what changed, that story will beat reciting specific SAM model phases every time. It's also why the training at Peck Academy, my licensed career school for people transitioning into the field, pairs foundational ID theory with Storyline 360 and AI skills rather than teaching models in the abstract.

If you want the pragmatic version of all this, I've written up a simple instructional design process that reflects how projects actually run, and a comparison of other instructional design models that shows where SAM sits among the alternatives.

How Does AI Change the SAM Model?

AI collapses SAM's most expensive step, prototyping, from days to minutes. That makes the model's core bet (working prototypes beat planning documents) much more relevant and accessible than it was pre-AI.

Think about what SAM was compensating for in 2012: prototypes were costly, so Allen had to argue hard that rough, disposable ones were worth building anyway. That argument is now free. When you can feed kickoff requirements into an AI agent and have a functional prototype online the same day, there's very little reason to route feedback through a static storyboard.

Project kickoffs still deserve a Savvy Start, though. That session is where you align on requirements, and if someone on the team can prototype quickly, you can even show early prototypes on the kickoff call itself.

Judgment is also more important than ever. When prototypes cost nothing, the bottleneck shifts to the review side of the loop: knowing what to change, what to cut, and when to stop. I see this constantly with my own product, devlin.ai, an AI simulation builder I founded where you describe a scenario in plain English and get a working voice or text simulation that embeds in Storyline, Rise, or any LMS. The instructional designers building in it often have an initial reaction of "wow, this is too easy, why am I needed?" Then, as they iterate toward the ideal simulation for their use case, they realize another designer wouldn't get anywhere near the same result. The tool made the prototype easy; their judgment is what makes each successive approximation better than the last. Fittingly, the tool itself started as an overly complex workshop build that I simplified through iteration, which is about as "SAM" as an origin story gets.

Your judgment is still what makes or breaks the effectiveness of a learning solution.

So the AI-era version of SAM looks like this: the same three phases and review discipline, but the design-prototype-review rotation takes hours instead of weeks. The designers who win with it are the ones who treat cheap prototypes as more chances to exercise judgment, not fewer reasons to think.

Frequently asked questions

What does SAM stand for?

SAM stands for Successive Approximation Model. The name comes from the behavioral psychology concept of shaping, where a target is reached through many small, reinforced steps rather than one large one.

Who created the SAM model?

Michael Allen created SAM. He introduced it publicly in the 2012 ASTD Press (now ATD) book Leaving ADDIE for SAM, co-written with Richard Sites, and his firm Allen Interactions uses the model in its client work.

Is SAM an agile methodology?

SAM is agile in spirit rather than a formal agile framework like Scrum. It shares agile's core principles (short iterations, working versions early, continuous stakeholder feedback, embracing change) but was built specifically for learning design projects.

Is SAM better than ADDIE for eLearning?

Neither is universally better. SAM tends to win for interactive eLearning with fuzzy requirements and available reviewers; ADDIE tends to win for compliance-heavy projects that need documentation and formal sign-offs. Most experienced teams blend the two.