Our delivery process

How we work, from the first call to long after launch

Every project at Zero One Creation follows the same delivery process: understand the problem, agree it in writing, design it, build it in short sprints you can see, test it, launch it and keep improving it.

This page shows each stage, what you see every week, the tools we use and what you receive when the work is handed over.

See the process
  • Demos on a preview link every sprint
  • Code and accounts in your name

What doesn't change

Four rules behind every project

Products differ. The way we run them doesn't. These four rules shape every stage below.

  1. 01

    Written before it is built

    Scope, acceptance criteria and terms are agreed on paper. Memory is a poor contract.

  2. 02

    Working software, not status reports

    You judge progress by clicking through it on a preview link, not by reading percentages.

  3. 03

    Senior people on your project

    Our in-house team does the work. The people in your demos are the people building it.

  4. 04

    Everything in your name

    Repositories, hosting, domains and accounts belong to you from the first day.

The process

Our software delivery process, stage by stage

For each stage: what happens, what you receive, and what we need from you. Projects that skip a stage usually pay for it later; the common reasons software projects fail map closely onto the stages people leave out.

  1. Stage 01

    First call

    Understand the problem

    A conversation about the problem, the people it affects, what exists today and any deadline that matters. We ask a lot of questions and keep the sales talk short.

    If we aren't the right team for the work, we say so on the call rather than after a proposal.

    You get

    • An honest view on fit
    • A recommended next step: discovery or a proposal

    Your part

    The problem in your own words, who it is for, and any constraints you already know.

  2. Stage 02

    Discovery

    Define it before building it

    For larger or less defined work, a short paid workshop. We map users and journeys, look at the systems the product must connect to, and name the risks while they are still cheap to deal with.

    Small, well-defined projects often go straight to a proposal.

    What a discovery phase covers

    You get

    • A written scope and prioritised plan
    • An architecture outline
    • A clickable prototype where the flow needs testing

    Your part

    Time with the people who know the process, and access to the systems involved.

  3. Stage 03

    Written proposal

    Agree everything in writing

    A document, not a number in an email. It sets out the scope, acceptance criteria, team, timeline, engagement model, payment milestones and a customised quotation, along with ownership and confidentiality terms.

    Nothing is built until you have agreed it in writing.

    How our engagement models work

    You get

    • Scope and acceptance criteria
    • Timeline and milestones
    • A customised quotation

    Your part

    Read it closely, push back on anything unclear, and sign when it is right.

  4. Stage 04

    Design

    Decide how it works and looks

    Flows and wireframes first, so structure is agreed before colour. Then visual design and clickable prototypes in Figma, reviewed with you screen by screen.

    For larger products we build a small design system, so new screens stay consistent long after launch.

    You get

    • Wireframes and user flows
    • Visual designs and prototypes
    • Design sign-off before build

    Your part

    Feedback on each round, and a clear sign-off before that area is built.

  5. Stage 05

    Sprint delivery

    Build in short, visible steps

    Development runs in short sprints. Each one starts with agreed priorities and ends with a demo of working software on a preview link you can open, click through and share.

    Every change goes through a pull request and a code review before it is merged. You can change priorities between sprints within the engagement model you chose.

    You get

    • A demo at the end of every sprint
    • A preview link that is always current
    • A visible backlog

    Your part

    Join sprint reviews, answer questions on the board, and make product decisions.

  6. Stage 06

    Quality assurance

    Test throughout, not just at the end

    Testing runs alongside the build. Code reviews catch problems early, automated tests cover the logic that would be costly to break, and we test on real devices and browsers, including accessibility and page speed.

    Before launch you test on a staging environment with real scenarios, and we fix what you find.

    You get

    • Tested features at each demo
    • A staging environment for your testing
    • A tracked list of issues and fixes

    Your part

    User acceptance testing with the scenarios your team actually runs.

  7. Stage 07

    Launch

    Go live calmly

    A launch checklist covers domains, SSL, analytics, error monitoring, backups and, for redesigns, redirects from old URLs. App releases include store listings and submission.

    We plan the go-live for a quiet period with a way to roll back, and stay close to it in the days after.

    You get

    • A checked launch
    • Monitoring and backups in place
    • Store submission for apps

    Your part

    Final approval, and the content and accounts the launch needs.

  8. Stage 08

    Support and improvement

    Keep it healthy, keep it growing

    After launch, software needs updates, monitoring and small fixes. Most clients continue with a monthly retainer or time and materials for improvements.

    We review how people use the product with you and agree the next priorities from evidence, not guesswork.

    You get

    • Updates, monitoring and fixes
    • Regular reviews of usage
    • A roadmap for what comes next

    Your part

    Tell us what users are saying, and decide what matters next.

Communication

What you see every week

This is how we run communication on every build. It is a working practice, not a service-level agreement, and we adjust it to your team's rhythm and timezone when we plan the project.

  1. Sprint start01

    Planning

    We agree what the sprint will deliver and what done means for each item.

  2. Every day02

    The board and the preview link

    Tasks move across a shared board, questions come to you there or in your chat tool, and the preview link updates as work is merged.

  3. Every week03

    A written update

    What was done, what is next, any risks, and the decisions we need from you.

  4. Sprint end04

    Demo and review

    A walkthrough of working software. Your feedback goes straight into the backlog for the next sprint.

Working across timezones? We agree overlap hours for calls and quick decisions when we plan the project, and keep everything else in writing on the board and in the weekly update, so nothing waits on a meeting.

Tools

The tools you'll see us use

Ordinary, well-known tools, so you can see the work without learning anything new. If your team already has a board or chat tool, we work in yours.

  • Figma

    Wireframes, visual designs and clickable prototypes, shared with you for comments.

  • GitHub

    Repositories in your organisation, pull requests, code reviews and automated checks.

  • A shared project board

    The backlog, sprint and status of every task. We can use your tool if you already have one.

  • Preview links

    Each piece of work deployed to a link you can open on any device before it goes live.

  • Your chat and calls

    Slack, Microsoft Teams, email or video calls, whichever your team already uses.

  • Written documentation

    Kept in the repository as the project grows, not written in a rush at the end.

Ownership and handover

Code ownership, documentation and a clean handover

Ownership isn't something we hand over at the end. Your repository, hosting, domains and accounts are set up in your name from the first day, and our contract assigns the intellectual property in the work to you.

Documentation is written as the project grows, so handover is a walkthrough rather than a scramble. Read how we handle access and credentials on our security and data protection page.

What you receive at handover

  • Source code in your repository, with the full history
  • A README with setup and deployment steps
  • Architecture notes and the data model
  • A list of environment settings and third-party services (names, never secrets in documents)
  • An admin guide for the people who will run it
  • A walkthrough session with your team
  • Credentials transferred and our access removed or reduced, as you prefer

Why it is built this way

Each stage exists to stop a known failure

Most failed projects fail in familiar ways. This is the risk each part of the process is there to remove.

Requirements nobody wrote down
Discovery and a written scope with acceptance criteria.
Surprises at the end
A demo of working software at the end of every sprint.
Scope creep
A change log, with each change estimated and approved in writing.
Bugs found by customers
Code reviews, automated tests and testing on real devices throughout.
Dependence on one vendor
Code, accounts and documentation in your name from day one.

Want to see how this would run for your project?

Tell us what you're planning. We'll walk you through the stages that apply, who you'd work with and what you'd see each week.

Before you talk to us

Frequently asked questions

How long does a project take?

It depends on scope, platforms and integrations, so we don't quote a standard timeline. After the first call we can give a rough idea, and the written proposal sets out a dated plan with milestones for your project.

How often will we see progress?

At the end of every sprint we demo working software on a preview link. In between, you get a short written update each week and can see every task on the shared project board at any time.

Who will we be working with?

People from our in-house team in Roorkee: a lead who is your main contact, and the designers and engineers building your product. The people in your demos are the people doing the work.

What do you need from us?

One person who can make product decisions, feedback at each review, the content and access the project needs, and time for testing before launch. Projects move fastest when questions are answered within the sprint they come up in.

Can we change priorities during the project?

Yes. On time and materials or a dedicated team you can reprioritise at every sprint planning. On a fixed-scope project, changes go through a written change log so the scope and quotation stay clear.

Can you work alongside our in-house developers?

Yes. We can work in your repositories, follow your branching and review rules, and join your rituals. If you want our engineers inside your team full time, that is our team extension service.

What happens after launch?

We stay close to the launch, then most clients continue with a monthly retainer for updates, monitoring and fixes, or time and materials for new features. We review usage with you and agree the next priorities.

Do we get the source code and documentation?

Yes. The code lives in a repository your organisation owns throughout the project, and documentation is kept alongside it. At handover we walk your team through it and transfer every credential.

Do you work with clients outside India?

Yes. The process is the same. We agree overlap hours with your timezone for calls and quick decisions, and keep everything else in writing on the board and in weekly updates.

Start with a call

Tell us about the project. We'll show you how we'd run it.

Share what you're building, who it's for and any deadline. We'll come back with questions, then a recommended next step: discovery or a written proposal.

We use your details only to reply to this enquiry. See our privacy policy.