Software development process: discovery, design, build, deployment Four steps, then it runs
ANTASY IT (a.it) delivers software in four steps: discovery, design and architecture, build in increments, deployment. Each step ends with something you can check: a written scope, mock-ups and a data model, a staging address, a production release. Then, if you want, we keep the system running.
- Steps to production
- Four, each with deliverables
- Work in progress
- On a staging address
- Project languages
- English or French
- Office hours
- Mon–Fri, 9:00–18:00 (UTC+1)

From scoping to production, then operations.
Overview
What are the steps of a software project with ANTASY IT?
Discovery turns your need into a written scope. Design fixes the screens, the data model and the hosting plan before any code. The build arrives in increments on a staging address you can test. Deployment moves data and users to production, with checks before and after the switch. Running the system afterwards is a separate, optional service.
01
Discovery
Goals, scope and constraints, mapped with the people who will use the software.
02
Architecture
Screens, data model and hosting plan, agreed before the first line of code.
03
Build
Delivered in regular, working increments that you can try and correct as they land.
04
Deploy
Released to production, data migrated and checked before and right after the switch.
05
Run
Monitoring, backups, updates and fixes, on servers we operate. Nothing is done until it runs.
- Build passes · type check
- Database migration rehearsed on a copy
- Health check on the new version
- Release checked again right after the switch
- Monitoring confirmed
Deliverables
What do you receive at each step?
Every step ends with documents or software you can open, check and keep, whether or not you continue with us.
Discovery: from a need to a written scope
We meet the people who will use the software, collect the documents they handle today (quotes, invoices, delivery notes, registers) and ask about volumes, rules and the systems to connect. If you already have a specification, we start from yours and list what is missing.
You receive
- A written scope with its exclusions and assumptions
- Roles and permissions, module by module
- An estimate by module
- A milestone plan, in the quote
Design and architecture: decided before code
We draw the key screens with your real vocabulary and documents, then design the data model that will hold them. When other systems are involved, the exchanges are written down as an API contract. The hosting plan says where the system will run and how it is backed up.
You receive
- Mock-ups of the key screens
- A data-model diagram
- An API contract, when systems must talk
- A hosting and backup plan
Build in increments, on a staging address
The software arrives piece by piece on a staging address with demo data, so you test real screens instead of reading reports. Each version comes with release notes in plain language: what changed, what to test, what is still open.
You receive
- A staging URL, updated at each increment
- Release notes for every version
- A short progress note: done, next, waiting on you
- Access to the code repository, as set in the contract
Deployment: production, checked before and after
Before launch, the data migration is rehearsed on a copy and the figures are checked with you. The release is checked before the switch and again right after it, and your administrators are trained on their accounts.
You receive
- The production URL
- Administrator accounts and credentials
- Administrator documentation
- A migration check: what was moved, and the counts
Run
After launch: we keep it running
Most client systems shown on this site run on servers we operate. When you choose this option, running the system is a monthly service, separate from the build, and covers four things.
- Monitoring
- Availability and errors are watched, so problems are seen before your users report them.
- Backups
- Databases are dumped on a schedule into files named with their date and time, and uploaded files are saved alongside them.
- Updates
- Security and dependency updates of the framework, the libraries and the server, within the agreed maintenance scope.
- Fixes and changes
- Defects are fixed; new needs are estimated, then delivered through the same steps.
Rhythm
How are progress and decisions shared during the project?
In writing first, so decisions are not lost: one shared channel, one named contact on each side, and each increment announced with its release notes. Calls happen when a demo or a decision needs them, in English or French, during office hours in Sfax (UTC+1). The rhythm of demos is set at the start of the project.
- Channel
- E-mail, your ticket tool or ours, and WhatsApp for quick questions. Agencies keep their own tools; we join them.
- Demos
- At an agreed rhythm, for example every week or every two weeks, always on the staging address.
- Decisions
- Every change of scope is written down, estimated and approved before work starts on it.
- Ownership
- Who owns the code, the accounts and the documentation is written in the contract, before the first line of code.
Acceptance
How is the work accepted, and what is a defect?
Each milestone is accepted on the staging address against test cases written from the scope. If the software does not do what the scope says, it is a defect and we fix it. If you want something new, it is a change: estimated, then planned. Acceptance criteria and warranty are defined in the contract.
| Defect | Change | |
|---|---|---|
| Definition | The software does not do what the written scope says | A new need, or a different way of doing something already agreed |
| Example | A total on an invoice does not match the agreed calculation rule | A new report, a new role, an extra field on a document |
| What happens | Fixed, then checked again on staging | Estimated in writing; you decide to add it, swap it or keep it for later |
| Cost | As the contract states for defects | Quoted before any work |
This is why the written scope matters: it is what both sides check the software against.
Specification
What should a software specification contain?
Enough for two vendors to quote the same thing: the goal, the users and their roles, the modules and screens, the business rules, the documents to print, the data to migrate, the systems to connect, the languages, the hosting, and what is out of scope. ANTASY IT writes it with you during discovery when you do not have one.
- Context and goals: the problem to solve, how success is measured
- Users and roles: who does what, who sees what
- Modules and screens: the main workflows, step by step
- Business rules: taxes, discounts, approvals, numbering
- Documents: what is printed or sent, in which layout
- Data: what comes from the old tools, and in which state
- Integrations: devices, third-party services, other software
- Languages, hosting, performance and accessibility needs
- Out of scope: what this project will not do
- Acceptance: how each milestone will be checked
Checklist
How do you choose a software development partner?
Ask to see software they run in production, not mock-ups. Check that the scope is written with its exclusions, that you can test the work on a staging address, that ownership of code and accounts is in the contract, and that someone will run the system after launch. Then compare quotes on scope, not on totals.
- Can I see systems you built that are in production today?
- Our answer: Yes: our clients and the systems we built for them are listed by name, with links to public sites. Clients
- Is the scope written, with what is excluded?
- Our answer: Always, before the quote. Nothing is priced from a one-line brief. Pricing
- Can I test the work before paying for a milestone?
- Our answer: Yes, on a staging address, with release notes for each version.
- Who owns the code, the accounts and the documentation?
- Our answer: It is written in the contract before work starts, and the handover list is part of deployment.
- Who keeps it running after launch?
- Our answer: We can, on our servers or yours, as a separate monthly service. Or we hand over to your team. Hosting and maintenance
- Which languages and hours do you work in?
- Our answer: English and French, Monday to Friday, 9:00–18:00 in Sfax (UTC+1). Working from Tunisia
FAQ
Process questions
How long does a software project take?
The duration is set in the quote, milestone by milestone, once the scope is written. It depends on the modules, the business rules and the data to migrate far more than on the technology. A first version limited to the core workflow is usually the quickest way to put working software in front of real users.
Do you write user documentation?
Administrator documentation is handed over at deployment, and every version comes with release notes. A user guide per role, annotated screenshots or training sessions are part of the scope when you need them: they are then listed in the quote like any other deliverable, so you know exactly what you will receive.
Can we follow the work while it is being built?
Yes. Each increment is deployed to a staging address with demo data, together with release notes that say what changed and what to test. You comment on real screens, not on reports. Depending on the contract, you can also have access to the code repository from the first commit.
Do you work in Scrum or Kanban?
We deliver in short increments whatever the label. On our own projects, the rhythm of demos and priorities is agreed at the start. When we work inside an agency or a product team, we follow its rituals and tools, whether that is Scrum sprints, a Kanban board or simply a shared ticket list.
Can our own developers take part in the project?
Yes. They can review code in the repository, take tickets or build parts of the system themselves. Conventions, branches and who approves what are agreed at the start, so the two teams do not get in each other’s way. It is also the smoothest way to prepare a handover to your team.
Which tools do you use to run the project?
The ones that fit the client: a shared ticket list or board, a Git repository, the staging address with its release notes, and e-mail or WhatsApp for quick questions. With agencies and product teams we use your tools instead. What matters is that every decision and every version is written down where both sides can find it.
Start with a written scope
Tell us the problem, the users and the deadline. Discovery starts with questions, not with a price.