SDLC

Habari Mwanafunzi! Welcome to the World of Systems!

Ever wondered how amazing applications like M-Pesa or eCitizen were built? Do you think the developers just woke up one morning and started coding? Not at all! Creating great software is like building a strong, beautiful house. You don't just start piling bricks and hope for the best. You need a plan, a blueprint, a structured process. In the world of technology, that master plan is called the Software Development Life Cycle (SDLC).

Ready to become a pro systems analyst? Let's lay the foundation stone by stone! In this lesson, we will break down the SDLC into easy-to-understand steps, using examples you can relate to right here in Kenya.

So, What Exactly is the SDLC?

The Software Development Life Cycle (SDLC) is a framework or a methodology that defines the tasks performed at each step in the software development process. Think of it as a recipe for cooking your favourite meal, like ugali and sukuma wiki. You have to follow the steps in order – boil the water, add the flour, cook, then prepare the sukuma wiki. If you mix up the steps, you get a mess! The SDLC ensures we create high-quality software that meets customer expectations on time and within budget, avoiding a digital mess.

Image Suggestion: A vibrant illustration showing a circular flow diagram with icons for each SDLC phase. In the center, a stylized logo of a Kenyan tech company. The style should be modern and colorful, reflecting the "Silicon Savannah" energy.

The 7 Major Phases of the SDLC

We will explore the most traditional and foundational model, the Waterfall Model. Just like a waterfall, each phase flows into the next one. You must complete one phase before moving to the next.

  PLANNING
     ↓
  ANALYSIS
     ↓
   DESIGN
     ↓
DEVELOPMENT
     ↓
  TESTING
     ↓
DEPLOYMENT
     ↓
MAINTENANCE

1. Phase 1: Planning & Feasibility Study (The "Tunaweza Hii Kitu?" Stage)

This is the very first step. Before writing a single line of code, we ask the big questions. Is this project even a good idea? We check if it is feasible in three key areas:

• Economic Feasibility: Will it make or save money? Is it worth the cost?
- Technical Feasibility: Do we have the technology and the skills to build it? - Operational Feasibility: If we build it, will people actually use it? Will it fit into the current way of doing things?

Kenyan Example: A Matatu Sacco in Nairobi wants a mobile app for passengers to book seats and pay via M-Pesa. In the planning phase, the Sacco management and a team of analysts would ask:

• How much will it cost to build and maintain the app? (Economic)
• Do we have developers who can integrate the M-Pesa API? (Technical)
• Will our drivers and conductors be able to use the system easily? Will our customers download it? (Operational)

Here's a very simple Cost-Benefit Analysis for our Sacco:

--- SIMPLE COST-BENEFIT ANALYSIS (First Year) ---

COSTS:
- Development Cost:       Ksh 500,000
- Staff Training:         Ksh  50,000
- Server & Maint.:        Ksh 100,000
-----------------------------------------
TOTAL COSTS:              Ksh 650,000

BENEFITS (Estimated):
- Increased Bookings:     Ksh 400,000
- Reduced Cash Handling:  Ksh 150,000 (less loss)
- Better Route Planning:  Ksh 200,000 (fuel savings)
-----------------------------------------
TOTAL BENEFITS:           Ksh 750,000

--- CONCLUSION ---
Net Benefit (Year 1) = 750,000 - 650,000 = Ksh 100,000
The project is economically feasible. Let's proceed!

2. Phase 2: System Analysis & Requirements (The "Watu Wanataka Nini Hasa?" Stage)

Once we get the green light, we need to understand exactly what the system should do. The goal is to gather all the user requirements. This is a critical step! If you misunderstand the requirements, you will build the wrong system. Analysts use tools like:

• Interviews: Talking to stakeholders (users, managers).
• Questionnaires: Collecting information from many people.
• Observation: Watching how people currently work.

The output of this stage is a Software Requirement Specification (SRS) document, which is like a contract that details everything the system will do.

// Information Gathering Flow

[Start] ==> Interview the Sacco Manager ==> Interview Drivers ==> Give Questionnaires to Passengers ==> Observe the Booking Clerk ==> [Compile SRS Document] ==> [End]

3. Phase 3: System Design (The "Kuchora Ramani" / Blueprint Stage)

Now that we know what to build, we figure out how to build it. This is the blueprint phase. We don't write code yet. Instead, we design the system's architecture.

• Logical Design: This is the abstract design. It includes drawing flowcharts and designing the database structure (what data to store, like `passenger_name`, `phone_number`, `seat_number`, `mpesa_code`).
• Physical Design: This is the concrete design. We decide on the programming language (e.g., Java), the type of database (e.g., MySQL), and the user interface (UI) – what the screens will look like.

Image Suggestion: A Kenyan UI/UX designer at a desk in a modern Nairobi office, sketching wireframes of a mobile app on a large tablet. The app interface clearly shows a matatu booking screen with fields for "From," "To," and a prominent "Pay with M-Pesa" button.

Here is a sample database table design for our Sacco App:

-- Table: Bookings --
+---------------+--------------+
| Field Name    | Data Type    |
+---------------+--------------+
| booking_id    | INT (Primary)|
| passenger_name| VARCHAR(100) |
| phone_number  | VARCHAR(15)  |
| route_id      | INT          |
| seat_number   | VARCHAR(5)   |
| mpesa_code    | VARCHAR(20)  |
| booking_date  | TIMESTAMP    |
+---------------+--------------+

4. Phase 4: Development & Implementation (The "Jengo Sasa" / Coding Stage)

Finally, the moment the programmers have been waiting for! The developers take the design documents and start writing the actual code. This is often the longest phase of the SDLC. The system is built module by module according to the blueprint from the design phase.

5. Phase 5: Testing (The "Kuangalia Kama Kila Kitu iko Sawa" Stage)

Would you move into a new house before an inspector checks the electricity and plumbing? Of course not! Similarly, before a system "goes live", it must be thoroughly tested to find and fix defects (bugs). Testers will try everything to "break" the system to ensure it's robust. What happens if a user enters their name in the phone number field? What if two people try to book the same seat at the exact same time? The testing team finds these problems so they can be fixed.

         / \
        / _ \
      | / \ |   Oh no, a BUG!
      | \ / |
       \_ _/
         |
      ---'---
     (=======) --- Let's fix it!
      `-----'

6. Phase 6: Deployment (The "Kufungua Duka" / Go-Live Stage)

This is the exciting part! The tested software is now ready to be delivered to the client and put into action. For our Matatu Sacco, this would involve:

• Uploading the app to the Google Play Store and Apple App Store.
• Installing the management dashboard on the Sacco office computers.
• Training the Sacco staff, drivers, and conductors on how to use the new system.

7. Phase 7: Maintenance (The "Service na Repairs" Stage)

The journey isn't over after deployment. Like a car, software needs regular maintenance to keep it running smoothly. This includes:

• Fixing bugs that were not found during testing.
• Making enhancements or adding new features based on user feedback.
• Updating the system to adapt to changes (e.g., a new Android version is released, or the M-Pesa API is updated).

A cautionary tale: A county government once tried to create a system for business permit applications without a proper SDLC. They skipped the Analysis phase and went straight to Development. The result? A system that was difficult to use, didn't work on mobile phones (which most business owners use), and couldn't handle the different permit types. They wasted millions of shillings and had to start over. This is why the SDLC is so important!

Final Thoughts: Your Blueprint for Success

Congratulations! You now understand the entire journey of creating software, from a simple idea to a fully functional system. The SDLC is your map and compass in the complex world of software development. It provides structure, reduces risks, and is the key to building amazing, reliable, and useful technology for Kenya and the world.

As you continue your studies in Systems Analysis and Design, you will learn about other models like Agile, but the fundamental phases we've discussed today are the bedrock of them all. Keep this blueprint in mind, and you'll be well on your way to building the next M-Pesa!

Food for thought: Which SDLC phase do you think is the MOST important for a project's success? Why?