Software development lifecycle
SumatoSoft will take you through every stage of the software development life cycle (SDLC) – from a business analysis stage through UX/UI and application development to deployment and ongoing support.
SumatoSoft SDLC vs. ADLC: which lifecycle fits your project?
SumatoSoft runs two distinct development lifecycles. The SDLC governs projects where human teams execute structured phases with documented requirements and formal sign-offs at each gate. The Agentic Software Development Lifecycle (ADLC) governs projects where AI agents take active roles in planning, code generation, or testing – with different governance requirements, hallucination controls, and cost-modeling frameworks as a result. The two lifecycles are not interchangeable, and the right one is determined during project scoping.
| Use SDLC when… | Use ADLC when… |
|---|---|
Requirements are defined and can be documented upfront or in a structured Discovery sprint. |
AI agents will perform significant parts of planning, code generation, or testing. |
The project requires formal phase approvals – regulated industries, government contracts, enterprise procurement. |
Specifications emerge through agent interaction and evolve during the build. |
Delivery teams are human-led with defined roles per phase. |
The project’s value proposition depends on autonomous agent execution. |
Predictable timelines and cost controls are a primary constraint. |
Project output depends on AI agent reasoning, retrieval, or generation – not deterministic rule execution. |
Requirements are defined and can be documented upfront or in a structured Discovery sprint.
The project requires formal phase approvals – regulated industries, government contracts, enterprise procurement.
Delivery teams are human-led with defined roles per phase.
Predictable timelines and cost controls are a primary constraint.
AI agents will perform significant parts of planning, code generation, or testing.
Specifications emerge through agent interaction and evolve during the build.
The project’s value proposition depends on autonomous agent execution.
Project output depends on AI agent reasoning, retrieval, or generation – not deterministic rule execution.
Software development lifecycle: 6 phases at a glance
Every SumatoSoft project moves through six phases in sequence. Each phase has a defined entry point, a set of documented deliverables, and an exit condition that must be met before the next phase begins. The sequence is the same across project sizes – scope and team composition vary, the structure does not.
Inside each SDLC phase: purpose, deliverables, team roles
Purpose: Define what gets built, for whom, and under what constraints – before design or development begins. Discovery converts business intent into documented requirements that the full team can build against.
Deliverables:
- Product backlog with MoSCoW-prioritised requirements
- Software Requirements Specification (SRS)
- Risk register with identified risks and mitigation notes
- Timeline and resource plan
- Project scope document and stakeholder sign-off
Team roles active in this phase:
- Account Manager
- Business Analyst (lead)
- Project Manager
- Solution Architect
Tools:
- Jira – backlog and task management
- Confluence – requirements documentation and SRS
- Miro – stakeholder workshops and process mapping
Purpose: Translate approved requirements into architecture and interface documentation that development teams can build against without ambiguity.
Deliverables:
- High-level design (HLD): module descriptions and dependencies, database schema, architecture diagrams, technology selections
- Low-level design (LLD): functional module logic, detailed database tables, interface specifications, module inputs and outputs
- UI/UX wireframes and clickable prototype
- API contract specification
- Architecture decision records (ADRs)
Team roles active in this phase:
- Solution Architect (lead)
- UX/UI Designer
- Project Manager
- Business Analyst (review and sign-off)
Tools:
- Confluence – HLD and LLD documentation
- Figma – UI/UX wireframes and interactive prototypes
- draw.io / Lucidchart – architecture diagrams
Purpose: Build the approved software in prioritised increments, with continuous integration and structured code review at each step.
Deliverables:
- Working software increments, reviewed and merged per sprint
- Automated test coverage for completed modules
- Sprint demos – recorded or live
- Updated product backlog after each sprint
- API documentation (Swagger / OpenAPI)
Team roles active in this phase:
- Developer (lead)
- Project Manager
- QA Engineer (running in parallel)
- Solution Architect (architecture governance)
Tools:
- Jira – sprint management and task tracking
- GitHub / GitLab – version control and code review
- GitLab CI / GitHub Actions – CI/CD pipeline
Purpose: Verify that the delivered software meets the accepted requirements and operates correctly under the conditions defined in the test plan.
Deliverables:
- Test plan and test case documentation
- Bug reports with priority and severity classification
- Regression test results
- Performance test report (where applicable)
- QA sign-off document
Team roles active in this phase:
- QA Engineer (lead)
- Developer (bug resolution)
- Project Manager
- Business Analyst (acceptance review)
Tools:
- Jira – bug tracking and status management
- Selenium / Playwright – UI and functional test automation
- Postman – API testing
- k6 / JMeter – performance testing (where applicable)
Purpose: Release the verified build to production under a controlled plan, with a confirmed rollback path and monitored stability.
Deliverables:
- Deployment plan and step-by-step runbook
- Production environment pre-deployment checklist
- Documented rollback plan
- Post-deployment monitoring report
- Go-live acceptance sign-off
Team roles active in this phase:
- DevOps Engineer (lead)
- QA Engineer (production verification)
- Project Manager
- Developer (standby for hotfixes)
Tools:
- GitLab CI / GitHub Actions – deployment pipelines
- Terraform / Ansible – infrastructure provisioning
- Grafana / Datadog – post-deployment monitoring
Purpose: Keep the delivered software stable, current, and aligned with evolving business requirements after launch.
Deliverables:
- Bug-fix releases on the agreed response SLA
- Dependency and security updates
- New feature increments per the maintenance backlog
- Periodic maintenance and health reports
- Incident reports for P1 and P2 issues
Team roles active in this phase:
- Developer
- QA Engineer
- Project Manager
- DevOps Engineer
Tools:
- Jira – maintenance backlog and release tracking
- Grafana / Datadog – monitoring and alerting
- PagerDuty / Opsgenie – incident management (where applicable)
Development frameworks we follow
The project’s requirements profile, delivery pace, and Client involvement pattern determine which methodology runs.
SumatoSoft uses Scrum when requirements will evolve and the Client wants regular influence over delivery priorities. Work runs in two-week sprints: each sprint opens with a planning session, runs with daily standups, and closes with a review and retrospective where the Client can adjust the backlog for the next cycle. Scrum suits most custom software projects where the full scope is not locked at the outset and Client feedback shapes what gets built next.
Continuous delivery work – maintenance contracts, support retainers, and feature expansion on live products – runs on Kanban. Work-in-progress limits keep throughput predictable. Tasks move through defined stages and are delivered as they complete, without waiting for a sprint boundary. The Client sees current status at any point through the board. Kanban works best when responsiveness to incoming requests matters more than a fixed release rhythm.
Engineering and delivery tools: the production stack across all phases
The tools below represent SumatoSoft’s typical production stack. Specific selections are adjusted per project based on Client infrastructure, team composition, and technology requirements.
| Category | Tools samples | Role in delivery |
|---|---|---|
Project management |
Jira (or similar like Trello, Notion, etc) |
Sprint planning, backlog, bug tracking, release management |
Documentation |
Confluence |
Specifications, runbooks, architecture records, decision logs |
Version control |
GitHub / GitLab |
Source code repository, pull requests, code review workflow |
CI/CD |
GitLab CI / GitHub Actions |
Automated build, test, and deployment pipelines |
Design |
Figma |
UI/UX wireframes, interactive prototypes, design system |
Code quality |
SonarQube |
Static analysis, security scanning, test coverage tracking |
Testing |
Selenium, Postman, Jest |
Functional, API, and unit test automation |
Cloud |
AWS / Azure / GCP |
Hosting, managed services, infrastructure provisioning |
Project management
Documentation
Version control
CI/CD
Design
Code quality
Testing
Cloud
Jira (or similar like Trello, Notion, etc)
Confluence
GitHub / GitLab
GitLab CI / GitHub Actions
Figma
SonarQube
Selenium, Postman, Jest
AWS / Azure / GCP
Sprint planning, backlog, bug tracking, release management
Specifications, runbooks, architecture records, decision logs
Source code repository, pull requests, code review workflow
Automated build, test, and deployment pipelines
UI/UX wireframes, interactive prototypes, design system
Static analysis, security scanning, test coverage tracking
Functional, API, and unit test automation
Hosting, managed services, infrastructure provisioning
How SumatoSoft estimates and prices projects
Estimation methodology
SumatoSoft estimates using a three-point model: each task receives an optimistic, most-likely, and pessimistic figure. Requirements are prioritised with MoSCoW to separate scope that must ship from scope that can flex. Estimates are broken down by module and task, with a risk buffer calculated against the project’s complexity and integration footprint. The output is an annotated range – not a single number delivered without explanation.
Pricing models
SumatoSoft structures commercial engagements under four models: Fixed Price for projects with well-defined scope; Time & Material for evolving or exploratory work; Time & Material with a budget cap for Clients who need flexibility within a spend ceiling; and Dedicated Team for Clients who need a fully staffed engineering function running under their direction. The right model is selected during Project Analysis, before the contract is signed.
SDLCÂ in practice: selected projects
SumatoSoft is the firm to work with if you want to keep up to high standards. The professional workflows they stick to result in exceptional quality.
Important, they help you think with the business logic of your application and they don’t blindly follow what you are saying. Which is super important. Overall, great skills, good communication, and happy with the results so far.
The system has produced a significant competitive advantage in the industry thanks to SumatoSoft’s well-thought opinions.
They shouldered the burden of constantly updating a project management tool with a high level of detail and were committed to producing the best possible solution.
I was impressed by SumatoSoft’s prices, especially for the project I wanted to do and in comparison to the quotes I received from a lot of other companies.
Also, their communication skills were great; it never felt like a long-distance project. It felt like SumatoSoft was working next door because their project manager was always keeping me updated. Initially.
We tried another company that one of our partners had used but they didn’t work out. I feel that SumatoSoft does a better investigation of what we’re asking for. They tell us how they plan to do a task and ask if that works for us. We chose them because their method worked with us.
Together with the team, we have turned the MVP version of the service into a modern full-featured platform for online marketers. We are very satisfied with the work the SumatoSoft team has performed, and we would like to highlight the high level of technical expertise, coherence and efficiency of communication and flexibility in work.
We can confidently say that SumatoSoft has put all our ideas into practice.
SumatoSoft succeeded in building a more manageable solution that is much easier to maintain.
Thanks to SumatoSoft’s can-do attitude, amazing work ethic, and willingness to tackle clients’ problems as their own, they’ve become an integral part of our team. We’ve been truly impressed with their professionalism and performance and continue to work with the team on developing new applications.
We are completely satisfied with the results of our cooperation and will be happy to recommend SumatoSoft as a reliable and competent partner for development of web-based solutions
From the early stages of the project, SumatoSoft demonstrated a proactive attitude, actively seeking opportunities to enhance the solution and anticipate our needs. They consistently took the initiative to address any potential issues, provide timely updates, and offer solutions to challenges that arose during development. This proactiveness greatly contributed to the project’s success and exceeded our expectations.
We brought in SumatoSoft to help us reduce unexpected turbine failures, and the result met our expectations.
Working with SumatoSoft has been an outstanding experience. Their team is not only highly skilled but also incredibly responsive, collaborative, and committed to delivering quality results. I can’t recommend them enough! Thank you team SumatoSoft for bringing my vision to life.
We’ve been working with SumatoSoft for a few years, starting from the initial monitoring system, so they already understood our environment quite well. At the same time, they still managed to surprise us with their professionalism.
We’d like to sincerely thank SumatoSoft for the work they’ve done on our maintenance system. At one point, our maintenance efforts became inefficient – long downtimes and rising repair costs became the norm.
We had already invested in AI, but the output was unclear. There were multiple initiatives across the company, each showing some promise, but no clear way to evaluate them or connect them to business outcomes.
Frequently asked questions about SumatoSoft’s SDLC
What is SumatoSoft’s software development process?
SumatoSoft’s SDLC runs in six sequential phases: Discovery, Design, Development, Testing, Deployment, and Maintenance. Each phase has documented deliverables, defined team roles, and an explicit exit condition – the next phase does not start until the current one is signed off. The process applies to custom software projects of all sizes, from initial builds to ongoing maintenance contracts.
How long does each SDLC phase take?
Phase durations depend on project scope and complexity. Reference ranges for a mid-size custom software project: Discovery – 2 to 4 weeks; Design – 2 to 6 weeks; Development – 2 to 12 months; Testing – runs in parallel with Development, with final acceptance taking 2 to 4 weeks; Deployment – 1 to 5 days; Maintenance – ongoing. SumatoSoft provides specific timeline estimates during Project Analysis, before any contract is signed.
When does SumatoSoft use Agile vs. Waterfall?
SumatoSoft uses Scrum or Kanban for projects where requirements evolve, Client involvement is continuous, and scope can adjust between delivery cycles. Waterfall is used for projects with clearly defined and stable requirements, projects requiring formal phase approvals – government contracts, large corporate procurement – and projects with strict compliance requirements. The methodology is selected during Discovery based on the project’s documented constraints.
What deliverables does SumatoSoft produce at each phase?
Discovery produces the Software Requirements Specification, product backlog, risk register, and project plan. Design produces high-level and low-level design documents and UI/UX specifications. Development produces reviewed and tested code increments and API documentation. Testing produces the QA report and acceptance sign-off. Deployment produces the production release and monitoring report. Maintenance produces bug-fix releases, updates, and periodic health reports.
How does SumatoSoft’s SDLC differ from its ADLC?
SumatoSoft’s SDLC governs projects where human teams execute structured phases with documented requirements and formal sign-offs. The Agentic Software Development Lifecycle (ADLC) governs projects where AI agents take active roles in planning, code generation, or testing – with different governance frameworks, hallucination controls, and cost-modeling requirements. Most projects run under the SDLC. Projects where AI agents perform significant delivery work are scoped under the ADLC from the outset.
Awards & recognitions
Let’s start
If you have any questions, email us info@sumatosoft.com
