What are the stages of software development?
The 6 stages every real software project goes through — Discovery, Design, Build, QA, Launch, AMC. Plus what your vendor SHOULD deliver at each stage.
Software development isn\'t one big "build" — it\'s 6 distinct stages, each with its own deliverables and risks. Understanding what should happen at each stage helps you choose the right vendor, hold them accountable, and avoid the typical disasters. Here\'s what each stage actually looks like.
Quick answer — the 6 stages
- Discovery — what should we build, why, for whom
- Design — how it should look and flow
- Build — the actual coding
- QA — testing for bugs and edge cases
- Launch — deploying to production, training users
- AMC / Maintenance — ongoing fixes, updates, evolution
Stage 1 — Discovery (1-2 weeks)
The most-skipped, highest-leverage stage. Without discovery, you\'re building blind.
What should happen:
- Workflow interviews with all user types (admin, manager, end-user)
- Pain point mapping — what\'s broken in the current process
- Goals and success metrics defined
- Technical constraints understood (existing systems, integrations, data volume)
- Architecture decisions (stack, hosting, scaling needs)
- Feature priority: must-have vs nice-to-have
- Timeline + budget estimate
Deliverable: written scope document + user flows + price + timeline. You sign off on this BEFORE design starts.
Red flag: vendor skips this and goes straight to "we\'ll build it." Result: constant scope confusion later.
Stage 2 — Design (1-3 weeks)
Visual + UX design happens before code. The reason: changing pixels is cheap; changing code after build is expensive.
What should happen:
- Wireframes (low-fidelity layouts)
- UX flows for each role
- Visual design system (colours, typography, components)
- High-fidelity mockups
- Click-through prototype tested with 3-5 actual users
- Designs locked + signed off
Deliverable: signed-off Figma file with every screen and state. No surprise designs in build phase.
Stage 3 — Build (4-32 weeks depending on scope)
The actual coding. This is where most clients think the "real work" happens — but it\'s only 50-60% of total project effort.
What should happen:
- Sprint-based development (1-2 week sprints)
- Weekly demos to client
- Staging environment from day 1 — client can test ongoing
- Code reviews internal to dev team
- Unit + integration tests written alongside code
- Continuous deployment pipeline
- Documentation as code is written
Red flags during build:
- No weekly demos (work hidden until end)
- "It\'s 90% done" repeated for 4 weeks (means 30% done)
- Big surprises in features not mentioned at scoping
- Code on vendor\'s personal laptop (should be in YOUR Git)
Stage 4 — QA (1-3 weeks)
Testing the software before users see it. Most-cut stage by cheaper agencies; biggest source of post-launch disasters.
What should happen:
- Functional testing — every feature works as specified
- Integration testing — Tally sync, payment gateway, WhatsApp, etc.
- Cross-browser / cross-device testing — Android device matrix is critical for India
- Network condition testing — 2G / 3G / Wi-Fi for mobile apps
- Load testing — what happens at 100 concurrent users? 1,000?
- Security testing — SQL injection, XSS, auth bypass
- UAT (User Acceptance Testing) — client team uses it for 1 week
- Bug fixing — every bug logged, prioritised, fixed
Deliverable: signed-off UAT + zero critical bugs + agreed list of "minor known issues for v1.1."
Stage 5 — Launch (1-2 weeks)
Deploying to production isn\'t a button-press — it\'s a coordinated effort.
What should happen:
- Production environment provisioned (AWS, DigitalOcean, etc.)
- Database migrated from staging
- Domain + SSL configured
- Monitoring + crash analytics enabled
- Backup strategy live
- App store submission (for mobile apps)
- User training sessions (role-wise)
- Recorded video walkthroughs
- Documentation handover
- Soft launch with internal team
- Full launch
Stage 6 — AMC / Maintenance (ongoing)
Software needs care after launch. Ongoing AMC covers:
- Bug fixes (production bugs surface that QA missed)
- OS / browser compatibility updates
- Security patches
- Server + infrastructure maintenance
- GST / regulatory updates (for Indian software)
- Minor feature additions
- User support questions
- Performance monitoring + tuning
- Regular backups verified
AMC cost: typically 15-25% of build cost annually. Don\'t skip this — software without AMC degrades within 12 months.
The build-only fallacy
Most clients budget for "build" and treat the rest as bonus. Reality:
| Stage | % of total project effort |
|---|---|
| Discovery | 5-10% |
| Design | 10-15% |
| Build | 50-60% |
| QA | 10-15% |
| Launch | 5% |
| AMC year 1 | 15-25% of build cost |
Methodologies — Agile vs Waterfall
| Aspect | Waterfall | Agile |
|---|---|---|
| Discovery | Big upfront | Light upfront, iterative |
| Design | Locked before build | Adjusted per sprint |
| Build | One long phase | Sprints with demos |
| Best for | Fixed-scope, regulated industries | Most SMB software, exploratory products |
| Risk | Late discovery of issues | Scope creep if undisciplined |
For 80% of Indian SMB software, Agile with disciplined scope = best path.
Common stage-skipping disasters
- Skipping discovery: 4 months of build, then realise wrong product
- Skipping design: developers make UX guesses, looks broken
- Skipping QA: launch crashes, 1-star reviews, store delisting
- Skipping training: team doesn\'t adopt, software wasted
- Skipping AMC: software degrades, security holes, no help when broken
What deliverables to demand from vendor
| Stage | Deliverable |
|---|---|
| Discovery | Written scope + price + timeline |
| Design | Figma file with all screens + click-through prototype |
| Build | Weekly demos + access to staging + code in Git |
| QA | UAT signoff + bug log + severity ratings |
| Launch | Production environment + training + documentation |
| AMC | SLA contract + monthly reports |
Pro tips
- Pay milestone-based: 30% on discovery signoff, 30% on design signoff, 30% on UAT signoff, 10% on go-live + 30 days
- Code in YOUR Git from week 1 — not just at handover
- UAT is your stage to be picky — test edge cases, network failures, weird inputs
- Plan AMC budget upfront, not as afterthought
- Get reference clients — talk to 2-3 past clients of vendor
Conclusion
Software development isn\'t a build — it\'s a 6-stage process. Each stage catches a different class of mistakes. Vendors who skip stages aren\'t saving you money — they\'re hiding cost in rework + production failures. If you want a vendor who runs the full process disciplined, see CRM development, ERP development or book a strategy call.
FAQs
Because 70% of software project failures trace back to bad scoping during discovery. A week spent on discovery saves a month of rework. Vendors who skip discovery are hiding it in extra "change requests" later.
For a 12-week project: Discovery 1-2 weeks, Design 2 weeks, Build 6-8 weeks, QA 1 week, Launch 1 week, AMC ongoing. Distorting this ratio (e.g. 1 day discovery, 10 weeks build) is a red flag.
Cheaper agencies often do. Result: bugs found by users in production, store reviews drop, churn. Reputable vendors budget 10-15% of project for QA.
Day 1 of production launch. AMC is not optional for software — bugs surface in production that no QA can catch. Standard AMC: ₹15K-₹1L/month depending on complexity.
Compress yes, skip no. The stages exist because each catches a different class of mistakes. Skipping QA = production bugs. Skipping design = rework. Skipping discovery = wrong product.
Build is biggest by hours. But discovery is highest-leverage — a small mistake in scoping multiplies through every subsequent stage.