Unit
- Definition: The software development life cycle is a structured process that guides teams from initial concept through deployment and maintenance. It creates checkpoints for review, reduces unexpected rework, and aligns engineering work with business value.
- Common phases: The standard phases are requirements gathering, system design, implementation, testing, deployment, and maintenance. Each phase produces artifacts that are reviewed before moving forward, which lowers ambiguity and increases confidence.
- Waterfall model: Sequential execution works well for projects with fixed scope and well-understood requirements. Teams complete each phase fully before starting the next, which can delay feedback and make late changes expensive.
- Agile model: Agile delivers in short iterative cycles, often called sprints. Stakeholders review working software early, and developers adjust priorities based on feedback, allowing the product to evolve responsively.
- DevOps culture: DevOps integrates development and operations by automating infrastructure and deployment. Continuous integration and deployment pipelines reduce manual steps, lower release risk, and speed up user feedback loops.
- Quality gates: At each stage, quality checks decide whether to advance. Code review, automated tests, security scans, and performance benchmarks act as gates that prevent harmful changes from reaching production.
- Stakeholder communication: Frequent status updates and demos keep expectations aligned. Clear documentation of decisions, risks, and assumptions prevents surprises and forms a project history for new team members.
- Process metrics: Teams measure lead time, deployment frequency, change failure rate, and mean time to restore. These metrics expose bottlenecks and guide process improvements without relying on opinions.
- Iterative and incremental delivery: Instead of delivering all features at the end, teams build the product in small increments and release them in repeated cycles. Each iteration includes analysis, coding, testing, and review. This approach reduces feedback delays, allows early validation of assumptions, and makes risk visible before too much investment is committed.
- Risk management: A mature SDLC identifies technical, schedule, and security risks at the start of every project. Teams rank risks by likelihood and impact, then define mitigation plans for the highest items. Reviews at phase boundaries ensure risks are reopened when assumptions change, preventing small issues from becoming release blockers later.
- Roles and responsibilities: Clear ownership prevents confusion during delivery. Business analysts define outcomes, architects set technical direction, developers implement features, testers verify quality, and operations staff manage releases. Cross-functional teams collaborate daily, but each discipline retains clear accountability for important decisions and artifacts.
- Compliance and audit trails: Regulated industries require traceability from requirements to code and test results. The process should preserve evidence of who approved changes, when they were approved, and what was validated in each environment. This documentation supports internal audits, external certifications, and legal reviews when the organization must prove its software is trustworthy.
System Architecture
Pattern: Continuous Delivery Pipeline
Components:
- Version Control: central repository that records every code change and provides a single source of truth
- Build Automation: compiles source, runs static analysis, and packages a deployable artifact
- Test Automation: executes unit, integration, and end-to-end tests to verify behavior
- Deployment Target: staging environment for validation and production environment for end users
Code Example
Python
phases = ['requirements', 'design', 'implementation', 'testing', 'deployment']
for phase in phases:
print('Executing phase: {}'.format(phase))This loop models the linear progression of a waterfall-inspired pipeline. Each phase name is printed when work begins. Modern teams would attach automated tools to each phase rather than using a loop.
Quick Revision
- The SDLC provides a repeatable framework for building and maintaining software.
- Waterfall suits stable categories, while Agile supports changing requirements through sprints.
- DevOps automation shrinks the distance between a commit and a production release.
- Quality gates and metrics reduce risks and improve delivery predictability.