Implementation & Maintenance: Coding, Testing, Deployment & Upkeep

Key Concepts & Workflow

1. Implementation Phase: Turning Design into Code

Implementation converts the system design into executable code. It involves:

• Programming: Writing code in languages like Java, Python, or C++ based on design specifications.
• Database Creation: Building the database schema (tables, relationships) as per the logical design.
• Integration: Combining modules (e.g., frontend, backend, APIs) into a unified system.
• Configuration: Setting up servers, environments (dev/staging/production), and third-party tools (e.g., payment gateways like Khalti).

How It Works (Step-by-Step)

flowchart TD
    A["Design Documents\n(ERD, DFD, UI Mockups)"] --> B["Code Development\n(Modules, APIs, DB Scripts)"]
    B --> C["Unit Testing\n(Individual Components)"]
    C --> D["Integration Testing\n(System Modules Together)"]
    D --> E["System Testing\n(Full System Validation)"]
    E --> F["Deployment\n(Staging → Production)"]

Real-World Example: eSewa’s Payment Gateway

• Idea Used: Modular Integration eSewa’s backend integrates with:
  • Nepal Rastra Bank’s API (for transaction validation).
  • Khalti’s SDK (for mobile payments).
  • Database triggers (to log transactions in real-time).
• How It Works:
  1. User selects "Pay Bill" → eSewa’s frontend sends a request to the backend.
  2. Backend validates the request via Khalti’s API and checks the DB for user balance.
  3. If approved, the transaction is recorded in eSewa’s PostgreSQL DB and synchronized with NRA’s ledger.

2. Testing: Ensuring Quality Before Deployment

Testing identifies defects and validates the system against requirements. Types of testing:

Worked Example: Daraz’s Order Queue System

Problem: During sales (e.g., "Daraz Days"), the order queue crashes due to high traffic. Testing Approach:

1. Load Testing:
   • Simulate 10,000 concurrent users using JMeter.
   • Goal: Ensure the queue system (Redis + Kafka) handles 5000 orders/sec.
2. Stress Testing:
   • Push 20,000 users to find the breaking point.
   • Result: System fails at 15,000 users → Scaled up to 3 AWS servers.
3. UAT:
   • 500 real users test the queue during a beta sale.
   • Feedback: "Order confirmation emails delayed by 2 mins" → Fixed by optimizing SMTP server.

3. Deployment: Releasing the System

Deployment moves the system from development to production. Strategies:

Real-World Example: WhatsApp’s End-to-End Encryption Rollout

• Strategy: Phased Deployment
  • Phase 1: Tested with 1000 beta users in Brazil (2014).
  • Phase 2: Rolled out to all users in 2016.
  • Why? To ensure no data leaks during transition.

4. Maintenance: Keeping the System Running

Maintenance ensures the system remains functional, efficient, and secure. Types:

Worked Example: Ncell’s App Crash During Loadshedding

Issue: Ncell’s app crashes when users try to check balance during power cuts (due to high server load). Maintenance Actions:

1. Corrective:
   • Patched the app to handle offline mode (cached data).
2. Adaptive:
   • Integrated with NTC’s SMS fallback system.
3. Preventive:
   • Set up auto-scaling in AWS for sudden traffic spikes.

In the Real World

1. eSewa’s Transaction Logging

   • Idea: Database Triggers + Audit Logs
   • How: Every transaction (e.g., electricity bill payment) triggers a DB log entry. If a user disputes a charge, eSewa’s support team retrieves the exact timestamp, amount, and recipient from the log.
   • Why It Matters: Prevents fraud and provides proof for disputes.

2. Daraz’s "Buy Now, Pay Later" (BNPL) System

   • Idea: Integration Testing + Load Balancing
   • How:
     • BNPL module integrates with Daraz’s inventory, user accounts, and payment gateways (Khalti, eSewa).
     • Load testing ensures the system handles 10,000 BNPL requests during sales.
   • Real Scenario: During "Daraz Days," 50,000 users enabled BNPL → System held up due to untested API limits → Fixed by adding a queue system.

3. Pathao’s Driver App Updates

   • Idea: Phased Deployment + User Feedback
   • How:
     • New features (e.g., "Tips" button) are rolled out to 10% of drivers first.
     • If 90% of them report no issues, it’s deployed globally.
   • Why It Matters: Reduces crashes for all 50,000+ drivers at once.

Exam Tip

1. Testing Questions:

   • Expect comparison tables (e.g., "Differentiate between unit and integration testing").
   • Worked examples: Be ready to explain how you’d test a real system (e.g., "How would you test NTC’s new billing portal?").
   • Tools matter: Mention tools like JMeter, Selenium, or Postman in answers.

2. Deployment Strategies:

   • Match the scenario: Big Bang for low-risk systems, phased for critical ones (e.g., banks).
   • Diagrams: Draw a simple deployment timeline if asked about rollout phases.

3. Maintenance:

   • Link to real systems: "Ncell’s app crashes during loadshedding" is a classic exam scenario.
   • Types: Always classify maintenance into corrective/adaptive/perfective/preventive.

4. Common Pitfalls:

   • Don’t confuse integration testing (modules together) with system testing (whole system).
   • Deployment ≠ Maintenance: Deployment is one-time; maintenance is ongoing.

Visual Summary:

mindmap
  root((Implementation & Maintenance))
    Coding
      Languages: Java, Python
      Databases: SQL, NoSQL
      APIs: REST, GraphQL
    Testing
      Types: Unit, Integration, System, UAT
      Tools: JMeter, Selenium
    Deployment
      Strategies: Big Bang, Phased, Pilot
      Example: WhatsApp Encryption
    Maintenance
      Types: Corrective, Adaptive, Perfective, Preventive
      Example: Ncell App Crashes