SDLC

Habari Class! Let's Build Some Software!

Ever seen a magnificent building go up in Nairobi? Or even a simple, strong house being built back in the village? They don't just start throwing bricks and hoping for the best, right? There’s a plan, a mchoro (blueprint), a fundi (foreman), and clear steps from the foundation to the roof. If you miss a step, the whole thing could come crashing down!

Well, building software is exactly the same. You can't just start writing code. You need a plan, a blueprint, a structured process to take an idea from a simple thought to a powerful application running on thousands of phones. That process, that master plan, is called the Software Development Life Cycle (SDLC). It’s our recipe for success!

So, What Exactly is the SDLC?

The Software Development Life Cycle (SDLC) is a structured process used by the software industry to design, develop, and test high-quality software. The goal is to produce software that meets or exceeds customer expectations, reaches completion within times and cost estimates, and is efficient to maintain and upgrade.

Think of it as the journey of software from birth (the idea) to retirement (when it's replaced). Following these steps helps us avoid chaos and create products that actually work and solve real problems for people.

The 7 Core Phases of the SDLC (The Classic "Waterfall" Way)

Let's walk through the most traditional and easy-to-understand model, the Waterfall Model. Imagine water flowing down a waterfall – it only goes one way, from top to bottom. Each phase must be completed before the next one begins. Simple and clear!

    +--------------------------------------+
    | 1. Planning & Requirement Analysis   |
    +---------------------+----------------+
                          |
                          v
    +---------------------+----------------+
    | 2. Defining Requirements             |
    +---------------------+----------------+
                          |
                          v
    +---------------------+----------------+
    | 3. Designing the Product             |
    +---------------------+----------------+
                          |
                          v
    +---------------------+----------------+
    | 4. Developing/Coding the Product     |
    +---------------------+----------------+
                          |
                          v
    +---------------------+----------------+
    | 5. Testing the Product               |
    +---------------------+----------------+
                          |
                          v
    +---------------------+----------------+
    | 6. Deployment in the Market          |
    +---------------------+----------------+
                          |
                          v
    +---------------------+----------------+
    | 7. Maintenance                       |
    +--------------------------------------+

1. Planning & Requirement Analysis

This is the "Je, tunataka nini haswa?" (What exactly do we want?) phase. It’s the most important stage. If you get this wrong, you build the wrong thing! Here, we figure out if the project is even a good idea (feasibility study) and gather the needs of the users (stakeholders).

Kenyan Example: Imagine you want to build a mobile app for boda boda riders in Kisumu. You wouldn't just guess what they need. You'd go there, talk to them, talk to their customers. You'd ask: "Do you need GPS tracking? A panic button? A way to manage daily earnings? Should it work on a cheap smartphone with low data?" All these questions are part of requirement analysis.

> **Image Suggestion:** [A vibrant, sunlit scene in a modern Nairobi tech hub. A diverse team of young Kenyan software developers (men and women) are gathered around a whiteboard covered in sticky notes and diagrams. They are actively brainstorming, laughing, and pointing at the board, collaborating on a new app idea. Style: Realistic, bright, and optimistic.]

2. Defining Requirements

Once you've gathered all the needs, you need to document them clearly in a Software Requirement Specification (SRS) document. This document acts as the contract. It details everything the software will do, without any ambiguity. It's the official guide for the designers and developers.

3. Designing the Product

Now the architects get to work! This phase is about creating the blueprint – the mchoro – for the software. It’s broken into two parts:

• High-Level Design: This is the overall architecture. Which programming language will we use? What kind of database? How will the different parts of the system (like user login, payments, and product display) talk to each other?
• Low-Level Design: This gets into the nitty-gritty details. What does each specific screen look like (UI/UX)? What does the database structure look like for the 'users' table? It's the detailed plan for each and every component.

    // ASCII Art of a simple Mobile App UI Wireframe

    +---------------------------------------+
    | O O O                         [10:30] |
    |---------------------------------------|
    |                                       |
    |          [   LOGO HERE   ]            |
    |                                       |
    |      +---------------------+          |
    |      |   Enter Username    |          |
    |      +---------------------+          |
    |                                       |
    |      +---------------------+          |
    |      |   Enter Password    |          |
    |      +---------------------+          |
    |                                       |
    |         +-----------------+           |
    |         |      LOGIN      |           |
    |         +-----------------+           |
    |                                       |
    |      Forgot Password? | Sign Up       |
    |                                       |
    +---------------------------------------+

4. Building or Developing the Product

This is the mjengo (construction) phase! The programmers, the software developers, finally get to write code. They take the design documents and turn them into a real, working product. They work in teams, often using tools like Git to manage different versions of the code so they don't overwrite each other's work.

5. Testing

No software is perfect on the first try. It will have bugs, or as we say, wadudu! The testing phase is all about quality control. Testers systematically try to "break" the software to find any problems before the customer does.

Real-World Scenario: Before Safaricom launches a new M-Pesa feature, you can be sure their Quality Assurance (QA) team has tested it thousands of times. They check if you can send money, if the amount is correct, if it works on different phones, if the system can handle millions of transactions during peak hours. This phase is critical for trust!

6. Deployment

Go-Live! This is the exciting part where the software is released to the users. This could mean installing it on servers, publishing it to the Google Play Store or Apple App Store, or rolling it out to employees in a company. The marketing team might launch a campaign, and the support team gets ready to help new users.

7. Maintenance

The journey isn't over after launch. The software is now live and needs to be cared for. This is the longest phase of the SDLC. It involves:

• Bug Fixing: Fixing issues that are discovered by real users.
• Upgrades: Adding new features to keep the product competitive.
• Enhancements: Improving performance and usability over time.

But Wait, There Are Other Ways! (SDLC Models)

The Waterfall model is great, but it's very rigid. What if a customer changes their mind halfway through? You'd have to start all over again! To solve this, other models were created. A very popular one today is Agile.

Agile Model

Think of Agile as building the house one room at a time, instead of all at once. You build a small, working piece of the software in a short cycle (called a "sprint," usually 2-4 weeks), show it to the customer, get feedback, and then build the next piece. It's flexible, fast, and great for projects where the requirements might change.

This is how many tech startups in Nairobi's "Silicon Savannah" work. They release a basic version of their app (a Minimum Viable Product - MVP), see how users react, and then quickly add the features people are asking for. It's all about adapting!

     +----------------------------------+
     |                                  |
     |   <--- Plan -> Design -> Build --+--+
     |         ^                        |  |
     |         |       (Iterate)        v  |
     |         +-- Test -> Review <-----'  |
     |                                     |
     +--------- [Release Working Part] ----+

> **Image Suggestion:** [A dynamic shot of a young, energetic team in a Nairobi co-working space having a 'daily stand-up meeting'. They are standing in a circle around a large Kanban board filled with colourful sticky notes. One person is speaking while others listen attentively. The atmosphere is collaborative and fast-paced. Style: Modern, candid photography.]

Let's Talk Money: A Simple Calculation

A key part of the planning phase is figuring out if a project is worth the cost. Let's do a simple Cost-Benefit Analysis for a local duka owner, Mama Benta, who wants an app to manage her stock.

    --- COST-BENEFIT ANALYSIS for Mama Benta's Duka App ---

    1. COSTS (One-Time)
       - App Development Cost (by a local freelancer): KES 50,000
       - Cheap Android Tablet for the shop:        KES 10,000
       --------------------------------------------------------
       - TOTAL INITIAL COST:                       KES 60,000

    2. BENEFITS (Monthly Savings)
       - Reduced stock going missing (better tracking): KES 4,000 / month
       - Less spoilage (app alerts on expiry dates):  KES 1,500 / month
       - Better ordering (no over/under stocking):    KES 2,000 / month
       --------------------------------------------------------
       - TOTAL MONTHLY BENEFIT:                       KES 7,500 / month

    3. CALCULATING RETURN ON INVESTMENT (ROI)
       - Formula: Total Cost / Monthly Benefit = Months to Break Even
       - Calculation: 60,000 / 7,500 = 8

    CONCLUSION:
    Mama Benta will recover the full cost of her investment in just 8 months!
    After that, she'll be making an extra KES 7,500 in profit every month.
    This is a worthwhile project!

Conclusion

Wow, that was a lot, but you made it! The SDLC is your roadmap to building amazing, reliable, and useful software. It's the difference between being a simple coder and a true Software Engineer. Whether you use the strict Waterfall model for a government project or a flexible Agile model for a fast-moving startup, understanding these phases is the key to success.

Now you have the blueprint. Go out there and start thinking about the next big thing that will change Kenya!