C# / .NET Compendium PLEN
.NET / C# / Process and methodologies

SDLC — Software Development Life Cycle

What it is

SDLC (Software Development Life Cycle) is a structured process describing all the phases of creating and maintaining software — from gathering requirements, through design and implementation, to deployment and ongoing support. It is not a specific methodology (like Scrum or Waterfall) — it is a general phase model which every methodology implements in some way (sequentially, iteratively, continuously).

The 6 phases of SDLC

1. Planning / Requirements Analysis

Gathering business and technical requirements, defining the scope, estimating cost and time, identifying risks. The outcome: a requirements document (functional and non-functional), a product backlog.

2. Design

Designing the system architecture: the division into modules/services, choosing patterns (e.g. SOLID, MVVM, CQRS — see the relevant topics on this site), designing the database, the API, the UI/UX. The outcome: architecture documentation, diagrams, API contracts.

3. Implementation / Coding

Writing code according to the design and the team's standards (code style, code review). This is where most of the technical topics on this site live in practice — design patterns, DI, EF Core, Web API.

4. Testing

Verifying that the software works according to the requirements and has no regressions: unit tests (xUnit, Moq), integration tests, manual tests/UAT (User Acceptance Testing). The outcome: test reports, a list of detected bugs.

5. Deployment

Making the software available to users: building, database migration (EF Core migrations), containerisation and orchestration (Docker, Kubernetes), deploying to the production environment (often through a CI/CD pipeline).

6. Maintenance

Monitoring the system in production, fixing bugs (bugfixing), supporting users, introducing minor improvements. This phase lasts the longest in the project's whole life cycle — often longer than all the previous ones put together.

Planning → Design → Implementation → Testing → Deployment → Maintenance
                                                                    │
                                                                    ▼
                                                        (wraca do Planning dla
                                                         kolejnych wersji/funkcji)

Models / methodologies implementing SDLC

The phases above are common to every approach — the difference is in how those phases are laid out over time.

Waterfall

The phases are carried out sequentially, one after another, with no return to the previous one (in theory). The whole project is first fully planned and designed before coding starts.

Planning → Design → Implementation → Testing → Deployment → Maintenance
   (each phase finishes 100% before the next one starts)

Advantages: predictability, clear documentation, works well for projects with an unchanging scope known well in advance (e.g. legally regulated systems).

Disadvantages: an error in the requirements detected at the testing stage is very expensive to fix (you have to go back to the start); no flexibility for change; the client sees a working product very late.

Agile / Scrum

Work is divided into short, iterative cycles (sprints), usually 1-4 weeks. In each sprint a small but complete and working product increment is produced — that is, in each sprint we go through planning → design → implementation → testing → (often) deployment in miniature.

Sprint 1: Plan → Design → Code → Test → Review  ─┐
Sprint 2: Plan → Design → Code → Test → Review  ─┼─► przyrosty produktu
Sprint 3: Plan → Design → Code → Test → Review  ─┘    (continuous feedback)

Advantages: quick feedback from the client, easy adaptation to changing requirements, a working product visible from an early stage.

Disadvantages: requires a lot of involvement from the client/product owner, and it is harder to predict the exact end and cost of the whole project up front.

DevOps / CI-CD (continuous integration / continuous delivery)

Extends Agile with automation and blurring the boundary between Development and Operations — code is built, tested and deployed continuously, often many times a day, through an automated pipeline.

Commit → Build → Automated Tests → (EF Core migrations) → 
  → Containerize (Docker) → Deploy (Kubernetes) → Monitor
  (the whole chain is triggered automatically on every commit/merge)

Advantages: very fast detection of errors (fail fast), small, frequent, less risky deployments, a strong linking of Testing-Deployment-Maintenance into one continuous process.

Disadvantages: a high upfront cost (CI/CD infrastructure, test automation), requires an organisational culture ready for frequent deployments.

V-Model (the verification and validation model)

An extension of Waterfall in which every design phase has a symmetrically corresponding testing phase — planned in parallel, before the code is even written.

Requirements Analysis  ──────────────────────  Acceptance Testing
      │                                                │
  System Design       ──────────────────────    System Testing
      │                                                │
  Architecture Design ──────────────────────  Integration Testing
      │                                                │
  Module Design       ──────────────────────      Unit Testing
      │                                                │
      └──────────────────► Coding ────────────────────┘

Advantages: tests are planned from the very beginning (not "tacked on" at the end), high rate of error detection at an early stage.

Disadvantages: just as rigid as Waterfall — it copes poorly with changing requirements.

Comparison

Model Flexibility When errors are detected Typical use
Waterfall low late (the Testing phase) projects with a scope fixed in advance and unchanging (e.g. regulated systems)
Agile/Scrum high continuously, every sprint products with evolving requirements, startups, most of today's software houses
DevOps/CI-CD very high immediately after a commit teams with mature automation, frequent deployments (SaaS, microservices)
V-Model low planned early, but rigidly safety-critical projects (medicine, aviation, finance)

Why this question comes up in interviews for the SE III position

At the Senior/SE III level, recruiters expect not only coding skills, but awareness of the process — an understanding that the code you write is one link in a larger cycle: that design decisions (Design) affect the cost of testing (Testing) and deployment (Deployment), that an error caught in Code Review is dozens of times cheaper than one caught in production, and that the ability to pick the right model (Waterfall vs Agile vs DevOps) for a project's context is a real engineering competence, not just "paperwork".

Buy me a coffee