The honest answer: it depends
Every agency says it. Every client hates hearing it. But the timeline for building an application genuinely depends on what you are building, how complex it is, and how prepared you are before development starts.
That said, you deserve better than a shrug. In this guide we break down realistic timelines for different types of applications, explain what drives the timeline in each phase, and share the patterns we have seen across dozens of projects delivered from our London studio.
Whether you are a startup founder planning your first MVP or an operations director digitising a manual process, this guide will help you set realistic expectations and avoid the most common delays.
Why timelines vary so dramatically
You will find wildly different estimates online. Some agencies claim they can build an app in four weeks. Others quote twelve months. Both can be telling the truth — they are just talking about very different things.
A simple content-based mobile app with three screens and no backend is a fundamentally different project from a multi-tenant SaaS platform with role-based access control, payment processing, and real-time notifications. Comparing their timelines is like comparing the time it takes to build a garden shed with the time it takes to build a house.
The key variables that determine timeline are scope and feature complexity, the number of integrations required, whether you need native mobile apps or a web application or both, the maturity of your requirements, your team's availability for feedback and decisions, and regulatory or compliance requirements specific to your industry.
Understanding these variables helps you estimate your own project more accurately than any generic benchmark.
Phase-by-phase breakdown
Phase 1: Discovery and planning (2 to 4 weeks)
Discovery is where you define what you are building and why. This phase includes stakeholder interviews, user research, competitive analysis, technical feasibility assessment, and architecture planning.
For a straightforward project with a single decision-maker and clear requirements, discovery can take as little as two weeks. For enterprise projects with multiple stakeholders, legacy system dependencies, and compliance requirements, expect three to four weeks.
What happens in discovery:
- Stakeholder alignment workshops — Getting everyone on the same page about goals, constraints, and priorities. This sounds simple but is often the most valuable part of the entire project.
- User research and persona development — Understanding who will use the application, what problems they face, and what workflows they currently follow. Even lightweight research — five user interviews — dramatically improves the final product.
- Technical architecture planning — Choosing the tech stack, defining the data model, planning integrations, and identifying technical risks. This is where experienced engineers earn their fee by spotting problems that would cost months later.
- Feature prioritisation and MVP scoping — Deciding what goes into the first release versus what comes later. The discipline to cut scope here directly determines whether you launch on time.
- Project roadmap and sprint planning — Breaking the work into two-week sprints with clear deliverables and milestones.
Discovery is not optional. Projects that skip discovery consistently take longer overall because they waste development time building the wrong things, discovering missing requirements mid-sprint, and reworking features that do not match user needs.
Phase 2: UX and UI design (3 to 6 weeks)
Design runs partially in parallel with the later stages of discovery. It starts with wireframes and user flows, progresses through visual design, and ends with interactive prototypes that look and feel like the final product.
For a simple application with five to ten screens, design takes three to four weeks. For a complex application with twenty-plus screens, multiple user roles, and detailed interaction patterns, expect five to six weeks.
The design phase includes:
- Information architecture — Organising content and features into a logical structure. This determines your navigation, page hierarchy, and how users move through the application.
- Wireframing — Low-fidelity layouts that define the structure of each screen without visual styling. Wireframes are fast to create and easy to change, making them the most efficient place to iterate on layout and flow.
- Visual design — Applying your brand identity, colour palette, typography, and visual hierarchy to the wireframes. This is where the application starts to look real.
- Interactive prototyping — Building clickable prototypes that simulate the user experience. Prototypes are invaluable for user testing and stakeholder buy-in because they let people experience the product before a single line of code is written.
- Design system creation — Documenting reusable components, spacing rules, and interaction patterns. A design system ensures consistency across the application and speeds up both design and development.
The biggest risk in the design phase is slow feedback. If stakeholders take a week to review each round of designs, a three-week design phase becomes a six-week design phase. We recommend committing to 48-hour feedback turnarounds.
Phase 3: Development (8 to 20 weeks)
Development is where the design becomes a working application. This is the longest phase and the one most affected by scope and complexity.
For an MVP with core features only, expect eight to twelve weeks of development. For a feature-rich application with integrations, complex business logic, and multiple user roles, expect fourteen to twenty weeks.
Development typically follows this pattern:
- Weeks 1 to 2: Foundation — Setting up the development environment, CI/CD pipeline, authentication system, database schema, and core application structure. This infrastructure work is invisible to end users but essential for everything that follows.
- Weeks 3 to 6: Core features — Building the primary user flows and essential functionality. By the end of this period, the application should be usable for its main purpose, even if many secondary features are missing.
- Weeks 7 to 10: Secondary features and integrations — Adding payment processing, email notifications, third-party API integrations, reporting dashboards, and other supporting functionality.
- Weeks 11 to 14: Polish and edge cases — Handling error states, empty states, loading states, responsive breakpoints, accessibility, and the hundred small details that separate a prototype from a production application.
- Weeks 15 to 20: Advanced features — For complex projects, this period covers features like real-time collaboration, advanced search, complex permissions systems, data migration tools, and admin dashboards.
Throughout development, we run two-week sprints with demos at the end of each sprint. This gives you visibility into progress and the opportunity to provide feedback before the next sprint begins.
Phase 4: Testing and QA (2 to 4 weeks)
Testing runs in parallel with development — we write automated tests as we build features — but dedicated QA time at the end of the project is essential for catching issues that only appear when the full application is assembled.
QA includes:
- Automated testing — Unit tests for business logic, integration tests for API endpoints, and end-to-end tests for critical user flows. These run automatically on every code change and catch regressions before they reach users.
- Manual testing — Exploratory testing by QA specialists who try to break the application in ways automated tests cannot anticipate. This includes testing on real devices, testing with slow network connections, and testing with unexpected user behaviour.
- Performance testing — Measuring page load times, API response times, and application behaviour under load. For applications expecting significant traffic, we run load tests simulating hundreds or thousands of concurrent users.
- Security testing — Reviewing authentication flows, authorisation rules, input validation, and data handling practices. For applications handling sensitive data, we recommend a third-party penetration test.
- Accessibility testing — Verifying compliance with WCAG 2.1 AA standards using both automated tools and manual screen reader testing.
- User acceptance testing (UAT) — Your team tests the application against your requirements and real-world scenarios. UAT is your opportunity to verify that the application meets your needs before launch.
Phase 5: Launch and deployment (1 to 2 weeks)
Launch preparation includes setting up production infrastructure, configuring monitoring and alerting, preparing documentation, training users, and planning the migration from any existing system.
For a new application with no data migration, launch can happen in a single week. For applications replacing an existing system with data migration requirements, expect two weeks.
Launch activities include:
- Production environment setup — Provisioning servers or serverless infrastructure, configuring DNS, setting up SSL certificates, and deploying the application.
- Monitoring and alerting — Setting up application performance monitoring, error tracking, uptime monitoring, and alerting rules so you know immediately if something goes wrong.
- Data migration — If replacing an existing system, migrating data from the old system to the new one. Data migration is often more complex than expected because source data is messy, inconsistent, or incomplete.
- User training and documentation — Creating guides, videos, or in-app walkthroughs that help users get started with the new application.
- Soft launch and monitoring — Releasing to a small group of users first, monitoring for issues, and gradually expanding access.
Typical timelines by project type
Simple marketing website with CMS
Total: 4 to 8 weeks
A brochure-style website with five to fifteen pages, a content management system, contact forms, and basic SEO optimisation. Design takes one to two weeks, development takes two to four weeks, and testing and launch take one to two weeks.
MVP mobile application
Total: 10 to 16 weeks
A mobile application with core functionality, user authentication, a basic backend, and deployment to the App Store and Google Play. Discovery takes two weeks, design takes three weeks, development takes eight to twelve weeks (including both the mobile app and backend API), and testing and launch take two to three weeks.
Web application with integrations
Total: 12 to 20 weeks
A web application with user authentication, role-based access control, third-party integrations (payment processing, email, CRM), reporting, and an admin dashboard. Discovery takes two to three weeks, design takes three to four weeks, development takes ten to sixteen weeks, and testing and launch take two to three weeks.
Enterprise SaaS platform
Total: 20 to 36 weeks
A multi-tenant SaaS platform with subscription billing, team management, advanced permissions, API access, white-labelling options, and comprehensive analytics. Discovery takes three to four weeks, design takes four to six weeks, development takes fourteen to twenty-four weeks, and testing and launch take three to four weeks.
Cross-platform mobile app (iOS and Android)
Total: 14 to 24 weeks
Using a cross-platform framework like Flutter, you can build for both iOS and Android simultaneously. This adds roughly 20 to 30 percent to the timeline compared to a single platform, rather than doubling it. The additional time goes toward platform-specific testing, App Store and Google Play submission processes, and handling platform-specific design patterns.
What causes delays and how to prevent them
Scope creep
The most common cause of project delays. Scope creep happens when new features are added during development without adjusting the timeline or budget. Small additions compound — "just one more feature" five times adds weeks to the project.
Prevention: Define a clear MVP scope during discovery and use a formal change request process for additions. Every new feature should be evaluated against the timeline impact before it is approved.
Slow feedback loops
When stakeholders take more than a few days to review work, the entire project slows down. Developers cannot proceed with dependent features, context is lost between feedback rounds, and the project loses momentum.
Prevention: Agree on feedback turnaround times before the project starts. We recommend a maximum of 48 hours for design reviews and 72 hours for sprint demos. Assign a single product owner with decision-making authority.
Unclear requirements
When requirements are ambiguous, developers must either guess (and risk building the wrong thing) or stop and ask for clarification (and wait for an answer). Both outcomes waste time.
Prevention: Invest properly in discovery. Write user stories with clear acceptance criteria. Create prototypes for complex interactions. Address edge cases before development begins.
Technical debt from shortcuts
Cutting corners during development to meet a deadline creates technical debt that slows down every subsequent feature. The first shortcut might save a day. The accumulated shortcuts can add weeks to the project.
Prevention: Maintain code quality standards throughout the project. Automated testing, code reviews, and regular refactoring prevent technical debt from accumulating to the point where it affects velocity.
Third-party dependencies
Waiting for API access from a partner, design assets from a brand agency, or data from an internal team are common blockers that are often underestimated during planning.
Prevention: Identify all third-party dependencies during discovery. Start procurement and access requests as early as possible. Build against mock APIs so development can proceed while waiting for real access.
Underestimating testing
Many projects allocate too little time for testing, assuming that if the code works on the developer's machine, it works everywhere. Real-world testing on various devices, browsers, and network conditions always reveals issues that need fixing.
Prevention: Allocate at least 15 to 20 percent of the total development time for dedicated QA. Write automated tests throughout development. Start UAT before the final sprint, not after it.
UK-specific considerations
GDPR compliance
If your application processes personal data (and most applications do), you need to design for GDPR compliance from the start. This includes consent management, data access requests, right to deletion, data portability, and breach notification procedures. Building these features into the application from the beginning adds one to two weeks to development. Retrofitting them later takes significantly longer.
Accessibility regulations
The UK Equality Act 2010 requires digital services to be accessible. Meeting WCAG 2.1 AA standards is not just a legal requirement — it is good business practice that improves usability for all users. Designing and developing for accessibility from the start adds minimal time. Fixing accessibility issues after launch can take weeks.
Payment processing
If your application handles payments, you need to comply with PCI DSS requirements. Using a payment processor like Stripe or GoCardless that handles PCI compliance for you is the most efficient approach. Integration typically takes one to two weeks depending on the complexity of your billing model.
App Store submission
If you are building a mobile app, factor in App Store and Google Play review times. Apple's review process typically takes one to three days but can take longer if your app is flagged for additional review. Google Play reviews usually complete within a few hours to two days. Allow at least a week in your timeline for the submission and review process.
How to keep your project on track
Start with a clear brief
Before engaging a development partner, document your objectives, target users, core features, integrations, and any constraints. A clear brief accelerates discovery and reduces the risk of misalignment.
Prioritise ruthlessly
Not every feature needs to be in the first release. Identify the minimum set of features that deliver value to users and focus on those. You can always add more features after launch based on real user feedback.
Stay involved
The most successful projects have engaged clients who participate actively in sprint reviews, provide timely feedback, and make decisions quickly. Your involvement is the single biggest factor in whether the project stays on track.
Plan for iteration
No application is perfect at launch. Plan for a period of post-launch iteration where you fix issues discovered by real users, add features based on feedback, and optimise performance based on real-world data. We recommend budgeting for at least four to six weeks of post-launch development.
Choose the right partner
An experienced development partner will help you avoid common pitfalls, make better technical decisions, and deliver a higher-quality product. Look for a partner with experience in your industry, a clear development process, and a portfolio of shipped products.
How Els Labs approaches timelines
We structure every project around two-week sprints with clear deliverables. Our discovery phase produces a detailed project roadmap with milestone dates that we track throughout the project.
We use continuous integration and continuous deployment, which means you see working software from the first sprint — not a big reveal at the end. This transparency keeps projects honest and makes delays visible early when they are easiest to address.
Our typical project breakdown:
- Discovery and design: 4 to 8 weeks (run partially in parallel)
- Development: 8 to 20 weeks depending on complexity
- Testing and launch: 2 to 4 weeks
- Post-launch support: Ongoing under a maintenance agreement
We build with Next.js, React, Flutter, Node.js, and PostgreSQL — a modern stack that enables rapid development without sacrificing quality or scalability. Every project includes automated testing, CI/CD pipelines, and production monitoring from day one.
Summary: realistic timelines
If you are planning an application project, here are the numbers to work with:
- Simple website or landing page: 4 to 8 weeks
- MVP mobile app: 10 to 16 weeks
- Web application with integrations: 12 to 20 weeks
- Enterprise SaaS platform: 20 to 36 weeks
- Cross-platform mobile app: 14 to 24 weeks
These ranges assume a well-run project with clear requirements, timely feedback, and an experienced development team. Add 20 to 30 percent for projects with unclear requirements, multiple stakeholders, or significant technical risk.
The best way to get an accurate timeline for your specific project is to start with a discovery phase. Two to four weeks of focused discovery will give you a detailed roadmap with confident estimates — and it will save you months of wasted effort building the wrong thing.
Ready to plan your project? Get in touch for a free initial consultation where we will discuss your requirements and provide a high-level timeline estimate.