IT project methodology: from requirements to production
A successful project starts with shared priorities. AXELITES turns a business need into a clear scope, then into a solution your teams can test, use and improve. A project manager is your single point of contact, from the first discussion to the production launch.
At every stage, you know what has been built, what awaits your approval and what comes next. Decisions, priorities and progress are written down in a shared tracking tool, and every work package ends with a demonstration of working software.
Discuss your project
A single point of contact
A project manager follows your project from scoping to launch and answers for the whole of it.
A demonstration per work package
You see the software working at the end of every work package, on an acceptance environment you can look at.
Written decisions
Priorities, trade-offs and requests are recorded in a shared tracking tool, with an owner and a date.
Your repositories, your access
Code, documentation and environments stay in spaces you control, from the first work package.
How we move forward, step by step
Six steps, each closed by your approval and by deliverables you keep.
Scope the need
We meet your users and business owners to understand the processes, the tools in place and the expected outcomes. Dependencies are listed at this stage: access, content, data to migrate, exchanges with your existing systems. Scoping ends with a scope ordered by priority and written success criteria.
- You approve:
- the scope, the priorities and the success criteria
- Deliverables:
- scoping note, prioritised scope, list of dependencies
Estimate and propose
The scope is split into work packages, each estimated separately, so you can choose between a first release and later improvements. The proposal states the team, the schedule, everyone’s responsibilities and the assumptions made. Technical uncertainties are investigated before the estimate is finalised.
- You approve:
- the split into work packages, the schedule and the budget
- Deliverables:
- proposal priced per work package, schedule, project organisation
Design the journeys
Mockups make the solution tangible before any code is written. Together we validate the key screens, the business rules and the data exchanges with your existing tools. The architecture and the technical choices are explained in writing, with their consequences for maintenance.
- You approve:
- the mockups and the business rules
- Deliverables:
- mockups of the key screens, specifications, explained technical choices
Develop in work packages
Development progresses in short work packages. Every delivery is reviewed by a second developer, covered by automated tests and deployed to an acceptance environment you can look at any time. A demonstration closes each package and your feedback feeds the priorities of the next one.
- You approve:
- each work package, at its demonstration
- Deliverables:
- working versions, acceptance environment, request tracking
Accept and launch
You test the agreed journeys on the acceptance environment, with an acceptance checklist prepared together. Defects are qualified, fixed and checked again. The production launch is planned with your teams: data migration, redirects, monitoring over the first days.
- You approve:
- the acceptance, then the production launch
- Deliverables:
- acceptance checklist, launch plan, cut-over report
Warranty, maintenance, improvements
After launch, a warranty period covers defects found in the delivered scope. Onboarding is supported: documentation, user training, transfer of access. Maintenance and later improvements are organised within an agreed framework, with the same routines.
- You approve:
- the end of the warranty and the maintenance framework
- Deliverables:
- documentation, transferred access, maintenance arrangements
Day to day: the routines that keep progress visible
The same routines apply in Paris, Montréal and Tunis, whatever the engagement model. They do not depend on one particular tool: we work in your tracking tools when you have them, or set up ours and give you access from day one.
- A regular progress meeting, with written minutes of the decisions taken
- A shared tracking tool where every request has a status, an owner and a priority
- A code review on every delivery and automated tests run in continuous integration
- Separate environments for development, acceptance testing and production
- A demonstration at the end of every work package, then a retrospective to adjust the method
- A monthly report on progress, quality and risks for long-running projects
The same method, whatever the engagement model
Fixed price, dedicated team, staff augmentation or maintenance: the routines stay the same, only the way priorities are set and billing adapt.
Fixed-price project
A scope, a price and a schedule committed after scoping, with a demonstration and acceptance at every work package.
Explore this engagement modelDedicated team
A named, stable team works on your product over time; you set the priorities at every meeting.
Explore this engagement modelStaff augmentation
One or more profiles join your team under your technical lead, with our quality checks.
Explore this engagement modelMaintenance and operations
Fixes, updates and improvements of an application in production, with agreed priorities and a monthly report.
Explore this engagement modelChanges, risks and dependencies
Needs evolve during a project: that is normal, and the method allows for it. Any request outside the agreed scope is described, estimated and presented with its consequences for the schedule and the budget, then you decide. The risks identified during scoping are reviewed at every progress meeting. The dependencies that rest with your teams, such as content, access or data to be provided, are tracked in the same tool as our own tasks.
- Out-of-scope requests are quoted separately, never quietly absorbed
- Risks and their mitigations appear in the minutes of every meeting
- Dependencies expected on your side have a date and an owner
- Code, documentation and access stay in repositories you control
Your questions about our method
Practical answers so you know what to expect before starting a project with us.
Discuss your projectBoth, depending on your need. A fixed-price project is scoped and then split into work packages, each committed on a scope, a price and a schedule. A dedicated team or a staff augmentation profile works in short iterations, with priorities you set at every meeting. In both cases the routines are the same: shared tracking tool, demonstrations, code review and written minutes.
It depends on the number of processes and systems involved. For an application or an online store of ordinary size, a few workshops are enough to produce a prioritised scope and a proposal per work package. Longer scoping is justified when integrations or data migrations need to be studied before committing: we tell you so from the first discussion.
The request is described, estimated and presented with its consequences for the schedule and the budget. You decide whether to add it to the current work package, defer it to a later one or drop it. Nothing is added to or removed from the scope without a written decision, so the budget stays readable until the end of the project.
An AXELITES project manager, based in France, follows the project from scoping to the production launch. They run the progress meetings, prepare the demonstrations and coordinate the developers, the designer and the tester. You can also talk directly with the team doing the work, in the shared tracking tools.
You do. The source code, the documentation, the environments and the access are placed in repositories you control from the first work package. Another team can take over the project at any time: this reversibility is planned from the contract onwards, and the documentation is kept up to date to make it possible.
The warranty covers the correction of defects found in the delivered scope, for a period set in the proposal. Improvements and new requests belong to maintenance or to a later work package. At the end of the warranty, we propose a maintenance framework suited to how the application is actually used.


