Skip to content
Colour theme

Our process · How software actually gets delivered

Our software development process: six stages from first call to a running product.

You always know what ships next, what it costs and when. Our software development process runs in six stages from first call to a running product, each ending in something you can hold: a written scope, a clickable prototype, a release you can use. No status updates without working software behind them.

If a stage does not produce something you can review, it is not a stage. It is a delay.

  • Since 2018

    Delivering software

  • Every 2 weeks

    Demo + written report

  • 50+ clients

    US · Europe · Middle East

  • 100% job success

    Upwork verified

Get your free estimate

Three quick questions: scope, approach and a price range back within 48 hours. No sales call required first.

What do you need built?
When do you want to start?
Where should we send the estimate?

Answer all three questions above, then send.

NDA-friendly · IP yours from day one

Trusted by companies worldwide

  • Bloomford
  • Contractor Plus, Inc.
  • Snappy Stats
  • Ad Lunam
  • Local Buzz
  • CyberFind
  • Hellory
  • 5.0Clutch · 8 client reviews
  • 4.9Google · 18 reviews
  • Top ratedUpwork · 100+ reviews · 5K+ hours worked
  • TopTracker7K+ hours tracked with clients

How we work

Four rules that decide everything else.

Most delivery problems are not technical. These are the working rules we hold to on every project, in every engagement model.

  • Rule 01

    Smaller scope, sooner

    We argue for the shortest version that answers the question. Everything else waits until real usage justifies it.

  • Rule 02

    Working software over reports

    Every two weeks you see the product running, not a percentage complete in a spreadsheet.

  • Rule 03

    One person accountable

    A named technical lead owns architecture and reviews every merge: quality never depends on who was free.

  • Rule 04

    Bad news early

    If something is slipping or was the wrong call, you hear it in the same sprint, not at the deadline.

The six stages

From first call to a running product in six stages.

The software development life cycle as we run it: discovery, scope, design, build, QA and launch, then support. Each stage has a named output and a rough timing, and you approve the one before the next begins.

  1. Discovery & problem framing

    A working call about the outcome, the constraints and what already exists, not a sales pitch. We push back where the problem is not yet a software problem.

    You receive: a summary of the goal, the constraints and the risks we can already see.

    Written problem statement · Days 1–3

  2. Scope, estimate & model

    We cut the scope to what proves the case, price it, and recommend which of our engagement models costs you least given how settled the scope already is.

    You receive: a written scope with a list of what we are deliberately not building.

    Scope, price range & plan · Within 48 hours

  3. Design & prototype

    Flows and screens for the core journey, turned into something clickable you can put in front of real users before a line of production code exists.

    You receive: screens, flows and a prototype link you can share with users and investors.

    Clickable prototype · Week 1–2

  4. Build in fortnightly sprints

    Working software every two weeks on a production stack, in your repositories, reviewed by a named technical lead on every merge.

    You receive: a demo you attend, a written report of what shipped, and access to the code.

    Sprint demo + written report · Every 2 weeks

  5. QA, hardening & launch

    Automated tests on critical paths, a security pass, staging sign-off, then deployment to your own cloud accounts with monitoring in place.

    You receive: release notes, documentation, credentials and a walkthrough with your team.

    Release notes & handover docs · Launch week

  6. Support, measure & iterate

    Real usage measured after launch, then the next slice of roadmap, or an honest recommendation to stop and rethink if the numbers say so.

    You receive: what users actually did, and a prioritised plan for the following release.

    Usage review & next-slice plan · Post-launch

Tooling & governance

How the work is tracked, reviewed and reported.

The same governance runs under every engagement model, only the commercial terms change; how we price projects is set out separately, model by model.

  • Your tools, not ours

    Jira, Linear, Slack or Teams: we work where your team already works, with your board as the single source of truth.

  • Named technical lead

    One senior engineer accountable for architecture and code review across the whole engagement.

  • Fortnightly demo and report

    A live demo you attend, then a written summary of what shipped, what slipped and what is next.

  • Time-zone overlap agreed up front

    Four hours with European or US mornings, full-day overlap for GCC clients, decided before kick-off.

  • Changes quoted in writing

    Added scope is priced and approved before it is built. Nothing is absorbed quietly or added silently.

  • Access from week one

    Your repositories, your cloud accounts, NDA signed, commit access from the first sprint.

The process in real projects

The same six stages, three different products.

Scoped, prototyped, built in sprints and shipped, with the stack decisions behind each one.

Our clients · reviews

Teams who trusted QalbIT

Short feedback from clients and products we work on across web, mobile, SaaS and internal tools.

  • Testimonials from long-term custom software development and SaaS product clients.
  • Covers ERP systems, B2B marketplaces, booking platforms, and web & mobile app development projects.
  • Real text and video reviews from founders, CTOs, and product teams who partnered with QalbIT for delivery.

  • Video review

    Rated 5 out of 5.
    “I would recommend QalbIT to everybody. QalbIT has been developing all my front-end & backend systems complete to my requirements. They have excellent technical knowledge and listen very well to the needs of their customers. And above all, they are great people.”
    Wouter SantensExecutive Search Consultant · Bloomford

  • Written review

    Rated 5 out of 5.
    “Excellent work! QalbIT team delivered the project on time, with great quality. Their ability to quickly adapt to new requirements and deliver promptly was impressive. Highly recommend them for Flutter projects.”
    Ahmed GFounder at Local Buzz · Consumer app / local discovery

  • Video review

    Rated 5 out of 5.
    “QalbIT quickly integrated four payment platforms: Square, Stripe, PayPal and Coinbase. Active communication, timely deadlines despite research-heavy work, plus post-launch support.”
    Roshan SethiaCTO · Contractor Plus, Inc.

  • Written review

    Rated 5 out of 5.
    “They took a half-finished marketplace, stabilised it, and shipped the modules we actually needed first. The weekly demos meant nothing came as a surprise.”
    Abhishek P.Product Lead · B2B marketplace

  • Written review

    Rated 5 out of 5.
    “QalbIT is a fantastic dev partner. They provide quality work, good communication and go above and beyond. Fantastic work delivered by QalbIT and his team. Can’t give enough credits with regards to how they work and at which speed they do it. Top team.”
    Joost HesselberthFounder · Ad Lunam

What protects you

The commitments that sit under the process.

Five things that stay true whichever model you choose, so the first engagement carries as little risk as we can put on our side of the table.

  • Replacement guarantee

    If an engineer is not the right fit we replace them at no extra recruitment cost, with handover before they leave.

  • IP and repos yours, day one

    Code, repositories and cloud accounts in your name under NDA, with commit access from the first week.

  • Changes quoted in writing

    Scope additions are priced and approved before they are built: the number never moves quietly.

  • 30 days notice

    Monthly engagements end or scale down with 30 days notice. No annual lock-in, ever.

  • No knowledge held hostage

    Documentation and training are part of delivery, so your team can carry the system without us.

Services that run on this process

Software development services at a glance.

From MVPs to long-term platforms, combine our core and specialised services to design, build and grow products that match how your business really works.

FAQs · our delivery process

Frequently asked questions about how we deliver software

Reporting, changes, delays and what happens when the plan turns out to be wrong: the questions worth asking before you sign anything.

Start with a scoping call →
Within 24 to 48 hours of the first call. You get a written scope, a timeline and a price range, free, and yours to keep whether or not you work with us.
A live demo every two weeks plus a written report of what shipped, what slipped and what is next. Code sits in your repositories the whole time, so nothing is hidden between demos.
We quote the change in writing with cost and timeline impact, and build it once you approve. On time and material engagements you simply re-prioritise at the next sprint boundary.
You hear it in the same sprint it happens, with the reason and the options. Deadlines slip quietly only when nobody is looking: our reporting cadence is designed to prevent that.
Yes. You meet the named technical lead and interview any dedicated team members before they join. There is no account manager standing between you and the people writing code.
You do, from day one: repositories, cloud accounts and IP in your name under NDA, with documentation and training handed over as part of delivery.
That is usually what we recommend. A fixed-scope first module or a two-week paid pilot shows you the process end to end before any longer commitment.
Six stages: discovery and problem framing, a written scope and estimate, design and a clickable prototype, fortnightly build sprints, QA and launch into your own cloud accounts, then support and measured iteration. Each stage ends in something you can review and approve.
Both, by stage. The scope is written and priced up front so you know what you are buying; the build then runs in two-week sprints with a demo and a written report at the end of each, so priorities can move without the number moving quietly.
Discovery takes days one to three, the written scope lands within 48 hours of it, the prototype in the first two weeks, and the build runs in two-week sprints until launch. A first release of a focused product typically ships in six to ten weeks.

Next step

Start at stage one: a scoping call.

Send the problem in two lines. You get a written scope, timeline and price range within 48 hours, free, and yours to keep either way.

Book my scoping call