Application Development Roadmap: Phases, Milestones and Example
9 min read ยท 2026-11-16
An application development roadmap is a plan that shows the phases, timing and milestones of building a mobile or web app, from the first discovery workshop to the weeks after launch. A good one fits on a single page and answers four questions: what gets built, in what order, who owns each phase, and how everyone will know a phase is done.
The example below follows a real type of project. An agency team builds a mobile app for a field service company's technicians, plus a web dashboard for the dispatchers who assign jobs. The durations are working assumptions for a project of this size, not benchmarks. Replace them with your own team's estimates before you present the plan.
The roadmap at a glance
Goal: Launch a technician mobile app and a dispatcher web dashboard, then reach a stable first version based on real usage. Duration: 33 weeks
Discovery (Weeks 1-3)
Agree on the problem, the users and what success looks like before anyone designs a screen.
- Interview 5 to 8 technicians and dispatchers about how jobs are assigned and closed today.
- List the systems the app must connect to, such as the scheduling tool, the CRM and the billing software.
- Write one measurable goal for the first version, for example "a technician closes a job from the phone without calling the office."
- Get a rough budget and timeline range approved by the client sponsor.
Milestone: Discovery brief signed by the client sponsor and the agency lead.
MVP scope and UX design (Weeks 4-7)
Decide what the first release contains, then design it.
- Turn user needs into a ranked feature list and mark each item "MVP" or "later."
- Draw user flows for the 3 to 5 most frequent tasks.
- Build a clickable prototype and test it with at least 3 technicians.
- Freeze the MVP scope in writing.
Milestone: MVP scope frozen and prototype approved.
Architecture and setup (Weeks 8-9)
Make the technical choices that are expensive to change later.
- Choose native or cross platform for mobile, and the stack for the web dashboard.
- Design the data model and the integrations with the client's existing tools.
- Set up the code repository, environments, and automated builds.
- Create developer accounts on the Apple and Google stores early.
Milestone: A test build runs on a real phone and connects to a staging server.
Build in sprints (Weeks 10-19)
Deliver working features every two weeks so the client sees progress early.
- Plan 5 two-week sprints, with the riskiest integration in the first sprint.
- Run a demo for the client at the end of each sprint.
- Track scope changes in a separate list and price them before accepting them.
- Write the store listing, privacy details and screenshots during the last sprint.
Milestone: Feature complete build delivered to QA.
QA and beta (Weeks 20-23)
Find what breaks before real customers do.
- Test on the phone models and OS versions the technicians actually use.
- Run a closed beta with one team of technicians in the field.
- Fix critical and major bugs, log minor ones for later.
- Check performance on weak mobile networks.
Milestone: Zero open critical bugs and beta users sign off.
Launch (Weeks 24-25)
Ship to the stores and train the people who will use the app every day.
- Submit to the App Store and Google Play, with buffer for review and possible rejection.
- Train dispatchers on the dashboard and technicians on the app.
- Roll out to one region first, then the rest.
- Set up crash reporting and a simple support channel.
Milestone: App live in both stores and used by the first region.
Post-launch iteration (Weeks 26-33)
Measure real usage and fix what matters most.
- Review crash reports and support requests every week.
- Compare usage against the goal set in discovery.
- Ship 2 to 3 small updates based on feedback.
- Plan the next quarter's roadmap with the client.
Milestone: Post-launch review held and next release scope agreed.
What an application development roadmap is, and what it is not
An app roadmap sits between strategy and day to day tasks. It shows phases and milestones over time, at a level a sponsor can read in two minutes. It does not list every ticket. Tickets live in the team's tracker, such as Jira or a Notion board.
People often mix it up with two other documents. A product roadmap covers the life of a product across many releases and is driven by outcomes, while the app roadmap usually covers one build, with a start and an end. A project plan goes deeper than both: tasks, dependencies, hours and resources. Keep all three linked, but never paste the project plan into the roadmap. The person reading the roadmap wants the shape of the plan, not the detail.
The detailed part should cover one to two quarters. Beyond that, show a lighter view with themes, such as "offline mode" or "customer portal," and no dates. Precise dates nine months out are guesses, and a sponsor will remember them as promises.
Waterfall, agile or hybrid: how the method changes your roadmap
The method decides what your milestones look like. In a waterfall plan, each phase ends before the next starts, and milestones are approvals: design signed off, build delivered, testing passed. This suits fixed price client work with strict requirements, but late changes are expensive.
In an agile plan, the build is a series of sprints, and milestones are working releases rather than documents. This suits products where the team expects to learn a lot from users. The risk is that sponsors see no clear end date.
Most client projects end up hybrid, like the example above. Discovery, scope and architecture run as fixed phases with sign offs. The build runs in sprints with demos. QA, launch and post-launch return to dated milestones. On the roadmap, show the sprints as one block with the demo dates marked, not as five separate bars.
Owners, dependencies and risks to put on the roadmap
Every phase needs one named owner. Shared ownership means nobody chases the milestone. In the example, the owners are listed below.
Next, mark the dependencies that can stop a phase. Typical ones are access to the client's systems, legal approval of privacy terms, and store accounts. Draw them as arrows into the phase they block.
Finally, list the top risks next to the dates they threaten. Three come up again and again: scope creep during the build, store review delays at launch, and forgetting how users will actually find or adopt the app. Late launches often come from unclear ownership, so name one owner per phase. Add a buffer of one to two weeks before launch, and say openly that it is a buffer. A hidden buffer gets spent on new features.
- Product or project manager: discovery, scope freeze, client communication, roadmap updates.
- Designer: user flows, prototype, usability tests.
- Tech lead: architecture, integrations, build quality.
- QA lead: test plan, beta coordination, bug triage.
- Marketing or client operations: store listing, training, rollout plan.
One plan, three views: executive, team and client
The same plan has to work for three audiences, and each one needs a different page. Build the full roadmap once, then make three views from it.
The executive view is one page with the phases as blocks, the milestones as dates, the budget status and the top three risks. No sprints and no feature lists. Executives want to know if the launch date holds and what could move it.
The team view shows sprints, owners, dependencies and the "MVP" and "later" lists. This is the view people open every week. It can change often without anyone needing to approve it.
The client view shows what the client must do and when: sign offs, content to provide, system access, beta testers, training dates. Clients often delay a project without realizing it, simply because nobody showed them their own milestones. Put their tasks in a separate lane so they are easy to spot.
Checklist before you send the roadmap
Run through these points before the roadmap goes to a sponsor or a client.
- Each phase has one owner and one milestone that someone can check as done or not done.
- Every milestone has a measurable test, such as "zero open critical bugs" rather than "testing complete."
- Dates beyond the next two quarters are shown as themes, not deadlines.
- Buffers before launch are visible and labeled.
- Client dependencies are in their own lane, with dates.
- The goal from discovery appears at the top of the page.
- The version and date of the roadmap are written in a corner, so nobody discusses an old copy.
Keeping the roadmap current after version one
A roadmap is out of date the day after a sprint demo goes badly. Review it every two weeks during the build, after each demo, and change only what the demo proved wrong. Then send the executive view again only when a milestone moves, with one line saying why.
After launch, the roadmap changes purpose. It stops tracking a build and starts tracking outcomes. Replace the build phases with the goal from discovery and the usage data that shows whether it was reached. That turns the app roadmap into the first page of a product roadmap.
Common mistakes to avoid
- Putting exact dates on work more than two quarters away, when themes without dates would keep the plan honest.
- Giving a phase two owners, instead of naming one person who answers for its milestone.
- Writing milestones like "design done," when "prototype approved by 3 technicians" can actually be checked.
- Leaving store submission to launch week, rather than creating accounts during setup and planning a buffer for review.
- Accepting new features during the build without a change list, instead of pricing each one and moving it to "later" by default.
- Sending the team view to executives, when a one page summary with dates, budget and risks is what they need.
Frequently asked questions
How do you make a roadmap for a mobile app?
Start from one measurable goal, then list the phases from discovery to post-launch and give each one an owner and a milestone. Estimate durations with the people who will do the work. Keep the next one to two quarters detailed and the rest as themes.
What comes first, strategy or roadmap?
Strategy comes first. The roadmap turns the strategy into phases and dates, so without a clear goal it becomes a list of features. Even a one sentence goal written in discovery is enough to start.
What is the difference between an app development roadmap and a product roadmap?
An app development roadmap usually covers one build, from discovery to the first months after launch. A product roadmap covers the product over its whole life, release after release, and focuses on outcomes. Once the app is live, the first often becomes the opening chapter of the second.
How do you present an app development roadmap to executives or a client?
Show a one page view with phases, milestone dates, budget status and the top three risks. For a client, add a separate lane with what they must provide and when. Keep the detailed sprint view for the team and bring it out only if someone asks.