WEBINAR ONDEMAND
How AI can become your main ally in creating your e-learning courses
Create professional courses in minutes, now for less.
Stay up to date with all our latest news
Subscribe to our newsletter Stay up to date with all our latest news
November 5, 2026
CONTENT CREATED BY:

Table of contents
The SAM model (Successive Approximation Model) is an iterative instructional design method: instead of analyzing, designing and producing in a straight line, it builds an imperfect prototype as early as possible and improves it in short cycles of design, prototyping and review until it reaches the final course.
It was developed by Michael W. Allen as an alternative to the ADDIE model, the most widespread until then, and it has become popular for one very concrete reason: it moves feedback to the start of the project, when fixing things is still cheap, instead of leaving it for the final review, when the content has already been produced.
In this guide you’ll see the model’s three stages, what the Savvy Start it begins with is, the four deliverables of the development phase, how SAM1 and SAM2 differ, when it beats ADDIE and — almost nobody mentions this — when you shouldn’t use it.
SAM stands for Successive Approximation Model, and the name describes exactly what it does: the steps repeat along the way until you progressively approximate the final design of the training. There’s no moment at which the design “closes”: there are versions that are progressively less bad.
Its central premise is that it is more efficient to develop a provisional prototype than to create the final content directly. Through successive cycles of creation, review and improvement, the model reaches a result that meets the learning objectives, but having discovered the problems while they were still cheap to fix.
Allen insists on one detail worth not overlooking: the prototype is a disposable tool. It isn’t a first draft of the course, it’s an instrument for the team to discover what matters and what doesn’t. If you feel bad throwing it away, you’ve over-worked it.
In this initial stage it’s important to establish a clear starting point. You need to gather the information that gives a realistic view of the road ahead, taking into account things like:
The process is meant to be fast, because the adjustments will be made as the prototype advances. Allen is blunt about this: you should do very little analysis, assume whatever is needed so as not to stall, and accept that it will be corrected later. Speed is part of the method, not a concession.
This phase starts with the Savvy Start, the brainstorming session we explain in the next section. From there, the team rotates between designing, prototyping and reviewing, so that everyone involved contributes to and backs the direction of the design before a single definitive screen exists.
What comes out of here isn’t the final training project: it’s a starting point on which reviews — and, through feedback, improvements — will be made. Only representative samples of the content are worked through in detail, never the whole course.
Here development, implementation and evaluation are tackled together. You move on to deep instructional design, covering every detail, in order to develop efficient, engaging content.
And here’s the part that usually gets told badly: this phase isn’t a single block, but four chained deliverables — design proof, alpha, beta and gold — each with its own review. If a design problem shows up in any of them, the process goes back to the previous phase instead of pressing on.
The Savvy Start is the brainstorming event that kicks off iterative design: the design team and the key stakeholders review the information gathered together and generate the first ideas, prototyping them on the spot. It’s the model’s most distinctive element and the one most often left out when summarizing it.
How long it lasts. According to Allen, it can take anywhere from half a day to three full days, or even more on large projects. It is not a one-hour kickoff meeting.
Who has to be there. This is the part that decides whether the Savvy Start works. Allen lists the profiles that should be sitting in that room:
What comes out of it. The performance objectives, listed alongside the prototypes that will help reach them, and enough information to build a project plan that holds up. There’s a side benefit Allen underlines, and that anyone who has suffered a late sign-off will recognize: whoever attended the Savvy Start understands your progress reports afterwards and doesn’t ask you to redo everything at the final review.
The iterative development phase has four named deliverables. Each one is reviewed before moving on to the next, and each answers a different question:
| Deliverable | What it is | What gets validated |
|---|---|---|
| Design proof | A visual, functional demonstration integrating samples of every component. It isn’t the course: it’s the proof that the course can be built. | That the design is feasible, that the chosen tools do the job, and that the experience is delivered reliably on the device, the network and the LMS the learner will use. |
| Alpha | The complete version of the course, with all the content and all the multimedia assets implemented. | That what was produced matches the approved design. This is where sequencing problems, missing content, unclear sections and functional faults show up. |
| Beta | The version corrected after the alpha, within what Allen calls the validation cycle. | That the corrections were done properly. It’s reviewed by experts and also by real learners from the target audience; by this point only typos or graphic tweaks should appear. |
| Gold | The final version, ready to deploy with no further development. | Nothing new: it ships. What should begin here, and almost never does, is studying whether the training actually changed the behavior it set out to change. |
When people talk about “types of SAM”, this is what they mean. Allen describes two versions of the model, and the difference isn’t one of theoretical complexity: it’s about who does the development.
The basic SAM diagram — the three phases, with their iterations — works as a complete process for small projects. That’s SAM1: when the design iterations finish, the product is finished. SAM2 appears when the project involves more than a handful of people, needs a formal budget and plan, or the development is carried out by a different team, sometimes an external one. In that case, when the design iterations end the project moves into a development phase of its own, which is where design proof, alpha, beta and gold come in.
| Criterion | SAM1 | SAM2 |
|---|---|---|
| Project size | Small: the team fits in one room and decides as it goes. | Large: more than a handful of people are involved and have to be coordinated. |
| Who develops | The same team that designs. | A different team from the design one, sometimes contracted externally. |
| Budget and plan | Informal, adjusted as you go. | Formal: you have to commit to figures and dates up front. |
| When the course is finished | When the design iterations close. | Afterwards, in a development phase with design proof, alpha, beta and gold. |
| When to choose it | Micro-courses, pilots, internal training for a single team. | Corporate programs, external vendors, projects with a steering committee. |
SAM was born as a response to the ADDIE model, so the comparison is unavoidable. But it isn’t a competition: the usual mistake is choosing by fashion instead of by context. ADDIE brings order, documentation and traceability; SAM surfaces the problems sooner. This table sums up how they differ and when each one weighs more:
| Criterion | ADDIE | SAM |
|---|---|---|
| Shape of the process | Linear: each phase closes before the next one opens. | Circular: designing, prototyping and reviewing repeat in short cycles. |
| When you see something tangible | At the end, once the content has been produced. | In the first few days, with a disposable prototype. |
| When feedback arrives | At the review, with the course already built. | From the Savvy Start, before anything is produced. |
| Cost of changing your mind | High: finished content has to be redone. | Low: you throw away a prototype, not a course. |
| What it demands of stakeholders | Signing documents at specific points in the calendar. | Being available and making decisions repeatedly. |
| When it suits | Closed requirements, regulated content, dispersed teams with little availability. | Open requirements, short deadlines, accessible stakeholders. |
You should promote effective communication and collaboration at every point to get the best results out of the SAM model. You need to build a foundation of trust, because the work with learners has to be close; and if you have a team of experts, it’s important that everyone understands what is expected of the training project.
Iterative development rests on quickly creating functional prototypes. This lets you actively test the course and make adjustments at an early stage, which saves time and resources. Remember that you need one prototype per type of content, not per piece of content.
It’s important to stay open and flexible in the face of feedback, because it is the key to the SAM model’s success. Create dedicated spaces and times for reviews and comments that help improve your instructional design.
At all times the main goal is to develop a successful learning model. Properly defining the learning outcomes before prototyping is what stops the iterations from becoming one change of mind after another: without a clear destination, iterating is just going round in circles.
Allen proposes starting from the last learning experience you would deliver before calling the instruction finished, and working back from there. It’s counterintuitive and it works: it forces you to define how the story ends before deciding how it starts, and it avoids courses that pile up content without knowing where they’re heading.
In every cycle, Allen labels tasks as Threshold (has to be in this iteration), Target (expected to be in it) or Future (saved for later). It looks like a minor detail and it’s what makes it possible to commit to a launch date — precisely what iterative methods are usually accused of being unable to do.
SAM is almost always presented as the modern option versus ADDIE, and that leads to using it in contexts where it doesn’t hold up. There are four situations where it’s better not to:
When the decision-maker can’t be there. The model puts all its weight on joint sessions and fast decisions. If the owner shows up once a month, the iterations turn into waiting, and you end up with the worst of both worlds: no documentation and no speed.
When the content is closed and regulated. In mandatory, certifiable or auditable training, what you’ll be asked for is the traceability of why the course says what it says. ADDIE gives you that by design; SAM, which pushes you to document the minimum, doesn’t.
When showing something imperfect is read as a lack of rigor. A disposable prototype is, by definition, ugly. If showing a draft damages your team’s credibility in your organization, SAM will generate distrust before it generates consensus. You can work on that, but you need to know it in advance.
When the project is tiny. A ten-minute micro-course doesn’t need three prototyping cycles: the cost of coordinating the iterations exceeds the cost of redoing it from scratch if it turns out wrong.
When the context supports it, the SAM model offers very clear advantages for your training:
They all come from the same source: the problems show up in week one and not in week twelve.
There is one fundamental condition for getting the benefits of the SAM model: that creating and adjusting prototypes is an agile process. The simpler it is to develop a first version, gather feedback and build in improvements, the more efficient each iteration will be and the easier it will be to move toward the final result.
With isEazy Author you can speed this process up thanks to its intuitive editor and its AI features, which let you create interactive e-learning courses, develop first versions and make adjustments quickly and easily, with no technical knowledge required. That way you can focus on perfecting the learning experience while cutting the time spent on production.
Try isEazy Author for free and find out how to speed up the creation of your e-learning courses.
The SAM model (Successive Approximation Model) is an agile, flexible approach to instructional design, developed by Michael W. Allen as an alternative to the ADDIE model. Unlike ADDIE, which follows a linear process, the SAM model is based on an iterative approach in which provisional prototypes are created and then adjusted and improved throughout development. This shortens planning times and delivers more efficient results through continuous feedback.
The SAM model is structured in three main phases. The first is the preparation phase, where key information about the objectives, constraints and needs of the course is gathered. Then, in the iterative design phase, ideas are generated and a first prototype of the training content is developed. Finally, in the iterative development phase, the design is implemented, evaluated with feedback and adjusted until an optimized final result is reached.
The SAM model offers multiple advantages when developing online training. Among its main benefits, it optimizes development times, reduces training costs and improves learners’ performance results. It also encourages more interactive, collaborative learning, since it involves teams in creating and improving the content. And it helps capture and hold learners’ attention thanks to its dynamic, progressive approach.
To implement the SAM model, it is key to encourage active collaboration between instructional designers and trainers, ensuring smooth communication. It is also recommended to commit to rapid prototyping, so you can identify improvements at an early stage and adjust the content based on the feedback received. Using tools such as isEazy Author makes applying this model easier, letting you create e-learning courses quickly, with interactive and multimedia content that keeps learners motivated.
It is the brainstorming session that kicks off the iterative design phase. The design team and the project’s key stakeholders review the information gathered together and generate the first ideas, prototyping them on the spot. According to Michael Allen it can last from half a day to three days, and it should include whoever decides and approves the budget, the subject matter expert, the performance supervisor, a representative learner and the person responsible for the rollout.
SAM1 is the basic model, designed for small projects: when the design iterations end, the course is finished. SAM2 is the extended version for large projects, with several teams, a formal budget and plan, or where development is done by a different team from the one that designs. In SAM2, once the design closes the project moves into a development phase of its own with four deliverables: design proof, alpha, beta and gold.
When the requirements are closed up front, when the content is regulated and you have to justify in writing why the course says what it says, or when the people responsible for the project can’t take part on a recurring basis. SAM needs fast decisions and available stakeholders; without those, the iterations turn into waiting and you lose the advantages of both models.
It depends on the project, but the model is designed so that something tangible appears in the first few days: the preparation phase should be very brief and the Savvy Start takes between half a day and three days. From there, each design iteration is measured in days, not weeks. Allen prioritizes each cycle’s tasks as Threshold, Target or Future precisely so that a launch date can be committed to.
Discover the No.1 authoring tool on the market
Try it freeRequest a demo
