Week 1 is structured discovery: we map the problem space (what specific friction or opportunity does this product address, and for which user segment), identify the core user journey (the single end-to-end flow that must work flawlessly for the MVP to be worth testing), and surface the technical risks early -- third-party API dependencies, regulatory requirements, infrastructure constraints, or integration complexity that would materially affect timeline or cost if discovered in week 6. We conduct stakeholder interviews with the founders and any domain experts who understand the user's current workaround (the spreadsheet, the manual process, the competitor they hate but use). By the end of Week 1, the scope is documented: what the MVP includes, what it explicitly excludes, which user personas it serves, and the acceptance criteria for the first launch. The fixed price is calculated from this scope document and locked in writing before any development starts. No surprises after work begins -- scope changes are costed as change requests, not absorbed and invoiced at the end.

Low-fidelity wireframes are produced in Figma before a single line of production code is written. The wireframe phase serves a specific purpose: it forces every ambiguous product decision to be resolved on paper, where changes cost minutes, not sprint days. The wireframes map each screen in the core user journey identified in Week 1 -- the specific sequence of interactions from entry point to the value moment. User flow annotations document the decision points, the edge cases (empty states, error states, permission denied states), and the data inputs and outputs at each step. After wireframe approval, high-fidelity UI design is produced using your brand guidelines and the component library that will be built during development: spacing tokens, color system, typography scale, and interactive states for every UI element. The design file becomes the single source of truth that developers implement from -- no interpretation required. Handoff to development uses annotated specs with exact spacing, color hex codes, responsive breakpoints (mobile 375px, tablet 768px, desktop 1280px), and component interaction notes. Designs are reviewed by the lead developer before the build phase begins to flag any UI patterns that would add significant implementation time without proportional user value -- design decisions made at this stage are ten times cheaper than in Week 8.

Development runs in two-week sprints using the approved tech stack (React/Next.js frontend, Node.js/NestJS backend, PostgreSQL database, Flutter for mobile where required, and AWS or Firebase for infrastructure). The first sprint always delivers the authentication layer, the core data model, and the primary user flow end-to-end -- the spine of the application that every subsequent sprint builds on. Working, deployed software is available at the end of every sprint at a staging URL: you interact with the real application, not a prototype, two weeks into the build. Sprint reviews are 30-minute video calls where the team demonstrates what was built against the acceptance criteria defined in Week 1. Any change to scope requested during the build is evaluated as a change request: scoped, priced, and added only if you approve -- it does not absorb into the project and appear on the final invoice. The tech lead and product manager have a synchronised view of velocity and remaining scope throughout the build. If any sprint runs behind plan, scope is renegotiated before it compounds -- not silently absorbed and then used to justify a deadline extension. All code is written to your specification: you own the repository from day one, the codebase follows documented conventions, and the handoff is an operational system with CI/CD pipelines, not a zip file of files.

QA is not a phase at the end -- it runs in parallel with every sprint so bugs are found and fixed while the context is still warm and the fix cost is lowest. Automated testing covers the critical user journeys with end-to-end tests (Playwright or Cypress) that run on every merge to the main branch via CI/CD pipeline; unit tests cover business logic, data transformation functions, and API contract validation; integration tests verify that third-party API connections (payment gateways, communication APIs, external data sources) behave correctly. Manual exploratory testing happens in each sprint on the staging environment, with testers working from user stories and edge case scenarios defined during scoping. Device and browser coverage is defined at the start: specific iOS and Android versions for mobile apps, and browser/viewport targets for web (typically Chrome, Safari, Firefox on desktop and mobile viewports at 375px and 1440px). Performance testing validates that the application handles the expected concurrent user load before launch -- a 500-user concurrent load test on the API is standard for consumer-facing MVPs. Any defect found is classified by severity: blocker (prevents a core flow from working, fixed in the same sprint), major (degrades a core flow, fixed before launch), and minor (cosmetic or non-blocking, documented and scheduled). The build phase does not close until all blocker and major issues are resolved and the regression test suite passes clean.

Production deployment follows a documented release checklist: environment variable audit, secrets rotation, database migration dry run against a production-size data snapshot, SSL certificate verification, CDN configuration, and load balancer health check configuration. Load testing (k6 or Locust) validates that the production infrastructure handles the expected traffic before the DNS switch -- traffic profile is based on the launch plan, not an arbitrary number. For mobile apps, App Store Connect submission and Google Play Console submission are handled by the team: provisioning profiles, signing certificates, metadata, screenshots at all required sizes, and privacy policy links are prepared and submitted. Apple App Store review typically takes 24--72 hours; Google Play review takes 24--48 hours for new apps. For web applications, DNS propagation is coordinated to minimise downtime (sub-30-second switchover using low-TTL pre-configuration). Monitoring is activated on launch day: uptime monitoring with alert thresholds, error rate tracking via Sentry or equivalent, and application performance monitoring (APM) dashboards. The codebase is transferred to your version control organisation, all API keys and credentials are transferred to your accounts, and all third-party service subscriptions are registered under your ownership -- you have no platform dependency on RaftLabs infrastructure after launch.

Eight weeks of post-launch support is included in every project at no additional cost. The support period covers bug fixes for any defects that emerge in production (issues that were not reproducible in the staging environment or that only manifest under real user behaviour at scale), performance tuning based on production monitoring data, and minor iterations based on early user feedback -- small UX adjustments, copy changes, or configuration tweaks that the first real users reveal. Support is delivered via a dedicated Slack channel with a maximum 4-hour response time during business hours and same-day response for production-down incidents at any hour. Sentry error tracking and uptime monitoring are active throughout the support period: the team is notified of production errors before most users encounter them, which means incidents are identified and triaged without waiting for a user report. If a bug introduced during development causes a regression in a previously working feature, it is treated as a defect and fixed within the support scope regardless of when it is discovered. Requests that go beyond bug fixing and minor iteration (new features, architectural changes, third-party integrations not in the original scope) are handled as a separate engagement priced against the same fixed-cost model. At the end of the 8-week support period, the team provides a technical handover document: architecture overview, deployment runbook, known technical debt, and a recommended feature roadmap based on the user data collected during the support period.