What Is the ADDIE Model? The 5 Phases of Instructional Design
By Devlin Peck · Updated
Part of the Instructional Design Fundamentals guide
The ADDIE model is a five-phase instructional design framework: Analysis, Design, Development, Implementation, and Evaluation. It was developed at Florida State University in 1975 for military training, and it remains the most widely used process for designing learning experiences.
I've worked in instructional design since 2017, and I earned my master's degree from FSU's Instructional Systems & Learning Technologies program, the same institution where ADDIE was created. In this guide I'll break down each phase with a running example, then answer the questions that come up most: where ADDIE came from, whether it's outdated, and how AI changes the work inside each phase.
What is the ADDIE model?
ADDIE is a process model that breaks the work of creating effective training into five phases. Each phase produces outputs that feed the next, so you always know what to do now and what comes next.
The five phases are:
- Analysis: figure out the problem, the audience, and whether training is even the right solution
- Design: plan the learning experience, from objectives to storyboards
- Development: build the finished course, video, or workshop materials
- Implementation: deliver the experience to learners
- Evaluation: measure whether it worked and decide what to revise
ADDIE is not tied to any format. It works for eLearning, instructor-led training, blended programs, and AI-powered simulations alike. The Association for Talent Development describes it as the ADDIE methodology that stands out as "the most prevalent in corporate education", and in my experience nearly every other instructional design model you'll encounter either builds on ADDIE or reacts against it.
Here's the whole model at a glance. This table is a breakdown of ADDIE itself, and we'll go deep on every row below.
| Phase | Core question it answers | Key outputs | Where it goes wrong |
|---|---|---|---|
| Analysis | What problem are we solving, and is training the answer? | Needs assessment, learner and task analysis, training plan | Skipped entirely; the "course" gets ordered before the problem is understood |
| Design | What will the learning experience look like? | Learning objectives, storyboards, design document | Objectives written around content instead of job behavior |
| Development | How do we build it? | Finished course, videos, facilitator guides | Endless review cycles; polish over substance |
| Implementation | How do learners get it? | LMS rollout, pilot group, comms plan | Treated as "upload the file and send an email" |
| Evaluation | Did it work? | Reaction and learning data, behavior and business results, revision list | Stops at satisfaction surveys and quiz scores |
Where did the ADDIE model come from?
ADDIE was created in 1975 by Florida State University's Center for Educational Technology, under contract with the U.S. Army. The work produced the Interservice Procedures for Instructional Systems Development (IPISD), a systematic training development process by Branson and colleagues intended for use across the Army, Navy, Air Force, and Marine Corps.
A few details from the history surprise most people:
- The acronym came later, and nobody knows exactly who coined it. The IPISD report describes the five-phase process, but the "ADDIE" label itself appeared afterward. Michael Molenda documented this in his 2003 paper "In Search of the Elusive ADDIE Model" in Performance Improvement, concluding that the term spread through oral tradition rather than a single authoritative source.
- The original version was strictly sequential. You completed each phase before starting the next. By the mid-1980s, practitioners had reshaped it into the more dynamic, iterative version used today.
- The military never stopped extending it. The U.S. Navy uses a variant called PADDIE+M, adding a Planning phase up front and a Maintenance phase for continuous improvement after rollout.
When I went through FSU's ISLT program decades after ADDIE was created there, the model was still a big part of the curriculum, though the program taught a variety of models alongside it. Practitioners would visit and share how they had specialized in one specific slice of ADDIE and built serious careers on it, up to and including paying off a first home with the work. This stuck with me: the model is broad enough that each phase is a career in itself.
What are the five phases of the ADDIE model?
The five phases of the ADDIE model are Analysis, Design, Development, Implementation, and Evaluation. Analysis defines the problem, Design plans the solution, Development builds it, Implementation delivers it, and Evaluation measures whether it worked.
I walk through all five phases in this video if you prefer to watch:
To make each phase concrete, I'll thread one example through all five: a software company where customer support escalations have doubled, and leadership has asked the L&D team for a "communication skills course." This is a composite example rather than a real client project, but it mirrors how these projects tend to unfold.
Analysis
During analysis, you gather the information that will guide every decision that follows: what the problem is, who the learners are, and what they need to do differently on the job.
Ideally, you start with a training needs assessment. This tells you whether training is even part of the solution. If the real problem is a confusing policy document or broken software, no course will fix it, and building one anyway wastes everyone's time. Once you've confirmed training will help, you move into learner analysis, job-task analysis, and context analysis.
The key questions to answer:
- What problem are we trying to solve?
- Is training the right solution, or part of it?
- Who are the learners, and what do they already know?
- What does great performance look like on the job?
- What constraints exist (time, budget, technology, access to learners)?
- How and when will the training be delivered?
In our support example: the intake conversation reveals that escalations cluster around refund disputes. Digging in, you find two causes. The refund policy document contradicts itself and buries the rules reps need most (a documentation fix, not a training problem), and reps have never practiced de-escalating an upset customer (a real skill gap training can address). You recommend fixing the document AND building practice-focused training, which is a much stronger recommendation than the "communication skills course" that was ordered.
In organizations in 2026, this phase looks like reviewing training intake forms, getting on calls with business stakeholders, and pushing back with better questions. Analysis is still the most-skipped phase, usually because designers take course orders instead of positioning themselves as consultants. Every time we comply without analyzing, we make it less likely the work helps the business, and that cheapens the reputation of the whole training function.
Result: you know whether training is needed, and if it is, you have a clear picture of the audience, the target behaviors, and the constraints.
Design
Design is where you plan the learning experience itself. This is instructional design, not graphic design: when people talk about instructional design as a discipline, this phase is usually what they mean.
You'll spend much of this phase with subject matter experts, turning their raw knowledge into something structured. The core activities:
- Writing learning objectives that describe observable job behavior, not vague awareness
- Sequencing content and choosing learning activities
- Deciding on media and delivery format
- Creating storyboards or scripts as blueprints for development
- Planning how you'll assess whether learners can actually perform
An instructional design document captures these decisions in one place so stakeholders can sign off before anything expensive gets built. If your deliverable involves slides, video, or eLearning screens, Mayer's multimedia principles should guide how you pair words and visuals.
In our support example: you write objectives like "Given an upset customer disputing a charge, resolve the conversation while correctly applying the refund policy." The design: a short self-paced module covering the (newly rewritten) policy, followed by scenario-based practice conversations with feedback. You storyboard both and review them with the support director and two senior reps.
In organizations in 2026, this phase is meetings with SMEs, reviewing their materials, and drafting storyboards, scripts, and content. It's also where designers coordinate with any specialists involved: media producers, developers, translators.
Result: approved objectives, a storyboard or blueprint, and a design document ready for development.
Development
Development is where the blueprint becomes the real thing: the storyboard becomes a functioning course, the script becomes a finished video, the facilitator guide content becomes a formatted, printable guide.
This is the most tool-heavy phase. As of early 2026, Articulate Storyline 360 and Rise remain the standard authoring tools in most corporate teams, while a growing number of instructional designers build custom learning experiences with AI coding agents like Claude Code or Cursor instead of (or alongside) traditional authoring tools. Either way, you're pulling together narration, images, video, and interactions, and running review cycles with SMEs and stakeholders until the product is ready.
A personal aside: development is where I hit flow state most easily. I can build until 2am with music on and stay in the zone, while design work takes much more deliberate focus for me. Plenty of designers are wired the opposite way, which is why some organizations split design and development into separate specialist roles.
In our support example: you build the policy module in Rise, develop the practice scenarios, record narration for videos, and run two review rounds with the support director. A senior rep catches a policy edge case your scenario got wrong. This is exactly what reviews are for.
Result: a finished, tested learning experience ready to deliver.
Implementation
Implementation is delivery: getting the learning experience in front of the target audience at the right time, with the right support.
For eLearning, this means publishing to the learning management system (LMS), enrolling learners, and notifying them. SCORM and xAPI, the technical standards you'll hear about here, are simply the protocols that let your course and the LMS report completions and scores to each other. For live training, implementation means scheduling sessions, preparing facilitators, and handling logistics.
The step most teams skip: a pilot. Running the experience with a small group first surfaces broken links, confusing instructions, and timing problems before the whole company sees them. Pair the rollout with real communication (why this training exists, what's expected, by when) rather than a bare LMS notification.
In our support example: you pilot with eight reps, fix two confusing screens they flag, then roll out to all 40 reps with a message from the support director explaining the new policy and the escalation problem the training addresses.
Result: learners have access, know why it exists, and are actually taking it.
Evaluation
Evaluation measures whether the training worked and tells you what to revise. It comes in two flavors, and the distinction is worth knowing:
- Formative evaluation happens throughout the project: SME reviews, storyboard feedback, pilot testing. It improves the product before full rollout.
- Summative evaluation happens after rollout and measures results.
For summative evaluation, the most common framework is Kirkpatrick's four levels: learner reaction, learning (skills and knowledge gained), behavior (on-the-job performance change), and results (business impact). You can extend this with a return-on-investment analysis if the stakes justify it.
In practice, most organizations stop at levels 1 and 2: satisfaction surveys and quiz scores. This leaves the most important questions (did behavior change? did the business improve?) unanswered, and it's the main reason training departments struggle to prove their value.
In our support example: pilot feedback was your formative data. For summative data, you compare refund-dispute escalation rates 90 days after rollout against the 90 days before, alongside QA scores on recorded calls. Escalations dropping is the result the project was commissioned to produce, and it's worth far more to your credibility than a positive survey.
Result: you know what worked, what didn't, and what to revise. And the revision list feeds right back into analysis, which is why modern ADDIE is a loop, not a line.
How does AI change each phase of ADDIE?
AI doesn't replace ADDIE's phases. It compresses the distance between them, turning work that took weeks into work that takes hours or days, which is exactly why the model now runs best as a tight loop.
My own workflow shows the shift. I used to work in a sequence: talk to stakeholders, prepare a storyboard or outline, collect feedback, build a prototype, collect more feedback, then develop the final product. Now I talk to stakeholders, feed the transcripts, notes, and materials to AI agents, review a high-fidelity prototype with the SME, feed that feedback back in, and repeat. I don't really spend time in eLearning authoring tools anymore; I build directly with Claude Code.
AI didn't remove the instructional designer from ADDIE. It moved us from doing to reviewing and steering.
Here's how it breaks down phase by phase:
| Phase | What AI does well now | What still needs a designer |
|---|---|---|
| Analysis | Summarizes intake forms, stakeholder transcripts, and SME materials; surfaces themes in performance data | Deciding whether training is the right solution; asking stakeholders the uncomfortable questions |
| Design | Drafts objectives, outlines, storyboards, and scripts from your notes | Judging what to cut, aligning objectives to real job behavior, sequencing decisions |
| Development | Builds working courses and prototypes, often in under an hour | Reviewing quality, giving feedback, iterating, accessibility and brand judgment |
| Implementation | Drafts rollout comms, course descriptions, and translations | Pilot decisions, change management, stakeholder alignment |
| Evaluation | Analyzes open-ended feedback and transcripts at scale | Choosing what to measure and connecting results to business decisions |
Development has compressed the most. AI agents can build learning experiences in under an hour without you even paying attention to them. It's still on you to give them feedback and do the iterations, but the hands-on-keyboard hours have collapsed.
One place this shows up clearly is practice. Realistic practice conversations used to be among the most expensive things an ID could build. Now you can describe a scenario in plain English and get a working voice or text simulation that embeds in Storyline, Rise, or any LMS, with AI evaluation, transcripts, and scores reporting back to the course. That's what my company, devlin.ai, builds, so I'm biased, but it shows what the development phase can look like now. Describe a scenario your learners need to practice and try the simulation it creates:
What are the advantages and disadvantages of the ADDIE model?
ADDIE's biggest strength is completeness: it names every kind of work an effective training project requires. Its biggest weakness is what happens when teams treat it as a rigid one-way sequence, or skip the phases that don't produce visible deliverables.
Advantages
- It's complete. ADDIE describes the full range of skills the instructional design job requires, from consulting and analysis through measurement. Master the five phases and you have the foundation for every other model in the field.
- It's shared vocabulary. Stakeholders, vendors, and teammates all know what "we're still in analysis" means. This alone saves projects.
- Employers expect it. In my Instructional Design Hiring Manager Report, 67.3% of hiring managers said candidates should be familiar with ADDIE. It shows up in interviews and job descriptions constantly.
- It makes projects estimable. Distinct phases with distinct outputs give you a clear basis for scoping time and cost.
Disadvantages
- Applied literally, it's a waterfall. If you complete every phase before starting the next, stakeholders don't see anything real until development, and problems get discovered late, when they're expensive to fix.
- Analysis and evaluation get skipped in practice. These are the two phases that connect training to business results, and they're the two organizations most often cut.
- It says nothing about speed. ADDIE tells you what to do, not how fast or how iteratively to do it. Teams that need rapid cycles have to impose this discipline themselves.
Is the ADDIE model outdated? What has replaced it?
No. Nothing has replaced ADDIE, and its vocabulary still structures how the entire field talks about its work. What has changed is how teams run it: as an iterative loop rather than a straight line.
Here's my current position. ADDIE is still the backbone of instructional design because it describes the full range of skills the work requires. But with AI, an iterative version of ADDIE is much more appropriate: you can start building prototypes and getting stakeholder feedback very early in the process. In my own work, I'll often go from analysis to a first prototype within 3 to 5 days, then repeat that cycle another 3 to 5 times before the experience rolls out to all learners.
The best-known alternative is the Successive Approximation Model (SAM), which builds iteration into the model itself rather than leaving it as an adaptation. Here's how they compare:
| ADDIE | SAM | |
|---|---|---|
| Shape | Five phases, traditionally sequential | Three phases (preparation, iterative design, iterative development) built around repeating cycles |
| First prototype | After design is documented | In the very first design cycle |
| Best for | Stable content, compliance topics, heavy sign-off requirements, distributed teams | Fast-moving content, available stakeholders, projects that benefit from early reactions |
| Documentation | Heavier, which large organizations often need | Lighter, which small teams often prefer |
| Main risk | Problems discovered late | Scope creep without discipline |
Two more pieces of evidence that ADDIE is being extended rather than retired: the Navy's PADDIE+M variant adds phases to ADDIE instead of abandoning it, and nearly all of the other instructional design models in serious use rearrange ADDIE's work rather than proposing different work.
Not sure how to run your next project? Answer a few questions and this will point you toward classic ADDIE, an iterative loop, or a SAM-style cycle:
Interactive tool
ADDIE Process Picker
Answer five questions about your project. You get a verdict with the reasoning: classic ADDIE, iterative ADDIE, a SAM-style cycle, or a hybrid, plus links back into the relevant sections of this guide.
Frequently asked questions
What does ADDIE stand for?
ADDIE stands for Analysis, Design, Development, Implementation, and Evaluation, the five phases of the instructional design process. Each phase produces outputs that feed the next, from the initial needs assessment through measuring results after rollout.
Who created the ADDIE model?
Florida State University's Center for Educational Technology developed the model in 1975 under contract with the U.S. Army, published as the Interservice Procedures for Instructional Systems Development (IPISD). The "ADDIE" acronym itself appeared later, and its exact origin is obscure; Michael Molenda's 2003 paper "In Search of the Elusive ADDIE Model" found no single authoritative source for the label.
Is the ADDIE model linear or iterative?
The original 1975 version was linear: each phase was completed before the next began. Since the mid-1980s, the standard version has been dynamic and iterative, with phases overlapping and feeding back into each other. Modern teams typically run ADDIE as a repeating loop, moving from analysis to a working prototype in days and cycling through feedback several times before full rollout.
Is ADDIE a learning theory?
No. ADDIE is a process model: it tells you what work to do and in what order, not how people learn. Learning theories like cognitivism and constructivism, and evidence-based principles like Mayer's multimedia principles, inform the decisions you make inside each phase.
Do employers still expect instructional designers to know ADDIE?
Yes. In Devlin Peck's Instructional Design Hiring Manager Report, 67.3% of hiring managers said candidates should be familiar with ADDIE, and it remains a fixture of ID job descriptions and interview questions. Even teams that run agile processes use ADDIE's phase names as shared vocabulary.
Next steps
If you're a practicing instructional designer, the highest-value move is to audit your own process against the two phases organizations skip most: analysis and evaluation. Pick one current project and add a needs-assessment conversation at the front or a behavior-level measure at the back. This alone puts you ahead of most training teams.
If you're using ADDIE to break into the field, learn the five phases well enough to walk through a project in an interview, because hiring managers will ask. This transition is what I help people make at Peck Academy, my licensed career school, where the training covers foundational ID theory, Storyline 360, and AI skills, with a curriculum reviewed by an advisory committee of 10 independent industry experts. It's my program, so weigh my recommendation accordingly.
Either way, the takeaway is the same: ADDIE has survived fifty years because it describes the real work. Learn the phases, then learn when to turn the phases into repeatable loops.