An introduction to systems thinking for people who want to build things that last

---

You Interact With Systems Every Day (Whether You Know It Or Not)

This morning, you probably:

• Woke up to an alarm (time management system)
• Brushed your teeth (personal hygiene system)
• Ate breakfast (food acquisition and preparation system)
• Commuted to work (transportation system)
• Checked your bank balance (financial system)
• Sent a message (communication system)

You didn't think of them as "systems." You just experienced them as either:

• ✅ Working (invisible, smooth, you barely notice)
• ❌ Broken (frustrating, slow, expensive, chaotic)

Here's the thing: Whether a system works or doesn't isn't random. It's not luck. It's not even about having money or technology.

Systems work when they're designed well. They fail when they're designed poorly.

And in Nigeria, we have a chronic problem: We keep building poorly designed systems, then blaming the people operating them.

---

So What Actually IS a System?

At the most basic level, a system is simple:

INPUT → PROCESS → OUTPUT

That's it. Three components.

Input: What goes into the system

Process: What happens to it

Output: What comes out

Let me show you:

---

Example 1: A Restaurant

Input:

• Raw ingredients (rice, tomatoes, chicken)
• Hungry customers
• Money

Process:

• Chef cooks the food
• Waiter takes orders
• Cashier processes payment

Output:

• Satisfied customers (hopefully)
• Revenue for the restaurant
• Empty plates

That's a system.

When the restaurant is well-designed:

• Food comes out in 15 minutes
• Customers are happy
• Restaurant makes profit

When it's poorly designed:

• Food takes 2 hours
• Customers complain
• Restaurant loses money

Same inputs. Different process. Different outputs.

---

Example 2: A Bus Terminal

Input:

• Passengers who want to travel
• Buses that can carry them
• Money for tickets

Process:

• Passengers buy tickets
• Board buses
• Buses depart

Output:

• Passengers reach destination
• Terminal makes revenue
• Drivers get paid

Sounds simple, right?

But go to any Nigerian bus terminal and you'll see chaos:

• Long queues (bottleneck in ticketing process)
• Buses leaving late (coordination failure)
• Missing money (fraud in payment process)
• Angry passengers (poor output quality)

It's not that Nigerians are chaotic people. It's that the system is poorly designed.

---

Example 3: Nigerian Education

Input:

• Young students (6-18 years old)
• Teachers
• Curriculum
• Classrooms

Process:

• Teachers teach
• Students study
• Students take exams

Output:

• Students who pass WAEC/JAMB
• (Ideally) Students who can think, solve problems, contribute to society

Now ask yourself:

Is the output what we actually want?

We're producing students who can:

• ✅ Memorize formulas
• ✅ Pass exams
• ❌ Solve real problems
• ❌ Think critically
• ❌ Innovate

Why?

Because the process is designed to optimize for exam passing, not learning.

The system is working exactly as designed. The design is just bad.

---

The Anatomy of a Good System

Not all systems are created equal. Here's what separates good systems from bad ones:

1. Clear Purpose (Know What Output You Actually Want)

Bad system:

"We need an education system."

Good system:

"We need an education system that produces students who can think critically, solve problems, and contribute economically to society."

Why this matters:

If you don't know what output you want, you can't design a process to achieve it.

Nigerian education optimizes for "students who pass exams" because that's the measurable output we designed for. We got exactly what we asked for.

---

2. Efficient Process (Minimum Steps, Maximum Value)

A good system eliminates:

• Unnecessary steps (bureaucracy that adds no value)
• Bottlenecks (one slow point that slows everything down)
• Redundancy (doing the same thing twice)
• Waste (time, money, effort that produces no output)

Example: Government Procurement

Current Process (Bad):

1. Ministry requests budget
2. Budget office reviews
3. Committee approves
4. Procurement department opens bidding
5. Bids are reviewed
6. Committee approves again
7. Contract awarded
8. Legal reviews
9. Finance releases funds
10. (6-12 months later) Work begins

Redesigned Process (Good):

1. Pre-approved categories (routine purchases don't need committee approval)
2. Digital bidding (automatic comparison)
3. Auto-approval under ₦5M threshold
4. Payment upon delivery verification
5. (2-4 weeks) Work begins

Same inputs. Same outputs. 90% less time.

The difference? Process design.

---

3. Feedback Loops (Know When Something Is Wrong)

Good systems have built-in ways to detect problems early.

Example: Healthcare

Bad system (No feedback loop):

• Patient gets sick
• Goes to hospital
• Doctor treats symptom
• Patient leaves
• No one tracks if patient got better

Good system (With feedback loop):

• Patient gets sick
• Goes to hospital
• Doctor treats symptom
• Follow-up appointment scheduled
• Doctor checks: Did treatment work?
• If yes: Continue. If no: Adjust treatment.
• Data collected: What works? What doesn't?

The feedback loop allows the system to improve itself.

---

4. Proper Incentives (Make It Easy to Do the Right Thing)

Systems produce the behavior they incentivize.

Example: Traffic Police

Current Incentive Structure:

• Police aren't paid well (₦50K-80K/month)
• No bonus for catching real criminals
• Incentive: Stop motorists, collect bribes (₦100K+/month in bribes)

Output: Police focus on checkpoints, not crime prevention.

Redesigned Incentive Structure:

• Pay police properly (₦250K/month)
• Bonus for crime reduction in their zone
• Severe punishment for bribery (fired + prosecution)
• Incentive: Reduce crime in your area

Output: Police focus on actual policing.

Same people. Different incentives. Different behavior.

The system shapes behavior. Not the other way around.

---

5. Scalability (Works at 10, Works at 10,000)

A good system doesn't break when you grow.

Example: Manual vs Automated Ticketing

Manual System:

• 1 ticket agent can handle 10 passengers/hour
• Want to serve 100 passengers/hour? Hire 10 agents
• Want to serve 1,000 passengers/hour? Hire 100 agents
• Cost scales linearly with volume

Automated System:

• Build a ticketing app once
• 1 server can handle 10 passengers/hour
• Same server can handle 10,000 passengers/hour
• Cost stays (mostly) flat as volume grows

Good systems are designed for scale from the beginning.

---

Why Nigerian Systems Keep Failing

Now that you understand what systems are, you can see why so many Nigerian systems don't work:

Problem 1: We Don't Define the Output We Actually Want

Example: JAMB

Stated goal: "Admit students to universities"

Actual goal (unstated): "Reduce number of students fighting for limited university spaces"

Result: A system designed to filter out students, not educate them.

We got what we designed for. We just never admitted what we were designing for.

---

Problem 2: We Copy Processes Without Understanding Context

Example: Copying Silicon Valley

Silicon Valley system:

• Input: Venture capital (abundant)
• Process: Fast experimentation, "fail fast"
• Output: Unicorn startups

Nigerian attempt to copy:

• Input: Venture capital (scarce)
• Process: Fast experimentation, "fail fast"
• Output: Companies that burn through cash and die

Why it doesn't work:

The INPUT is different (capital scarcity in Nigeria vs abundance in Silicon Valley).

You can't copy a process designed for different inputs and expect the same outputs.

Systems must be designed for their actual context.

---

Problem 3: We Have No Feedback Loops

Example: Road Construction

Current System:

• Road is built
• Ribbon-cutting ceremony
• Everyone celebrates
• No one tracks: Does the road last? Does it reduce travel time? Is it maintained?

5 years later: Road is full of potholes, worse than before.

Why?

No feedback loop. No one measured success beyond "Did we build it?"

Without feedback, systems can't improve.

---

Problem 4: Our Incentives Are Broken

Example: Civil Servants

Current Incentive:

• Paid the same whether you work hard or not
• Promotion based on years served, not performance
• No penalty for poor work
• Incentive: Do the minimum, don't rock the boat

Output: Inefficient government services

Redesigned Incentive:

• Bonus for measurable improvements (faster processing, fewer complaints)
• Promotion based on results
• Consequence for incompetence
• Incentive: Actually serve citizens well

Output: Better government services

Fix the incentives, you fix the system.

---

Problem 5: We Don't Design for Scale

Example: Most Nigerian Startups

Initial design:

• Founder does everything manually
• "We'll figure out scaling later"

At 100 users: Founder is overwhelmed

At 1,000 users: System collapses

Result: Complete rebuild needed

Why?

System wasn't designed to scale. It was designed to work once.

Good systems are built for 10x growth from day one.

---

How to Think About Any System

Whenever you encounter something broken—traffic, education, healthcare, business process—ask these questions:

1. What's the actual INPUT?

Not what you wish it was. What actually goes in.

2. What's the actual PROCESS?

Map it step-by-step. Where are the bottlenecks? Where's the waste?

3. What's the actual OUTPUT?

Not what it's supposed to be. What actually comes out.

4. Is the output what we actually want?

If not, the system is working as designed—the design is just bad.

5. Where are the feedback loops?

How does the system know when it's failing?

6. What are the incentives?

What behavior does the system reward?

7. Will this scale?

What happens when you 10x the volume?

---

A Real Example: Let's Analyze Lagos Traffic

Let me show you how to apply this:

INPUT:

• 20 million people
• 2 million cars
• Limited roads

PROCESS:

• Everyone drives at the same time (8am, 5pm)
• No coordinated public transport
• No enforcement of traffic rules
• Okadas weaving through traffic

OUTPUT:

• 3-hour commutes
• ₦500B+ annual productivity loss
• Stress, pollution, accidents

Analysis:

Question 1: Is this the output we want?

Answer: No.

Question 2: Why is the process producing this output?

Answer:

• Bottleneck: Everyone traveling at peak times (no staggered work hours)
• No alternative: Public transport is unreliable (so everyone drives)
• No feedback loop: Government doesn't measure commute times or productivity loss
• Wrong incentive: Okada riders incentivized to be reckless (paid per trip, not per safe trip)

How to Redesign:

Option 1: Reduce Input During Peak Times

• Incentivize staggered work hours (tax break for companies that allow 7am or 10am start times)
• Result: Spread the load across more hours

Option 2: Improve Alternative Process

• Reliable BRT network (dedicated lanes, frequent buses)
• Subsidize public transport (make it cheaper than driving)
• Result: Fewer cars on road

Option 3: Fix Incentives

• Okada riders licensed, required to have clean record
• Bonus for safe rides (tracked via app)
• Result: Safer, more orderly traffic

Option 4: Add Feedback Loop

• Measure: Average commute time per route
• Publish: Real-time traffic data
• Penalty: Roads that consistently fail get priority for expansion
• Result: Data-driven infrastructure planning

Notice:

I didn't say "build more roads" (that's adding more process).

I looked at inputs, incentives, alternatives, and feedback.

That's systems thinking.

---

The Most Important Lesson

Systems produce the outcomes they're designed for.

If Nigerian education produces students who memorize but can't think—the system is working as designed.

If Nigerian hospitals have long queues and poor care—the system is working as designed.

If Nigerian businesses can't scale—the system is working as designed.

The problem isn't the people in the system.

The problem is the system itself.

And the beautiful thing about systems?

They can be redesigned.

---

What You Should Do Next

If you're a builder (founder, manager, civil servant, anyone creating something):

Stop jumping to solutions. Start with systems thinking:

1. Define the output you actually want (not what sounds good, what you actually want)
2. Map the process (step by step, no skipping)
3. Identify dysfunction points (bottlenecks, waste, misaligned incentives)
4. Redesign the process (eliminate, simplify, automate)
5. Test with real users (pilot before scaling)
6. Measure the output (did you get what you wanted?)
7. Iterate based on data (fix what's broken, keep what works)

If you're stuck with a system you can't change (employee, citizen):

Understand how it works. When you understand the system, you can:

• Navigate it better (work with the incentives, not against them)
• Explain why it's broken (to people who can change it)
• Design alternatives (and prove they work better)

---

Final Thought

Nigeria doesn't lack smart people. We don't lack resources. We don't even lack ideas.

What we lack is systems thinking.

We keep building things that break. We keep blaming people for systemic failures. We keep copying processes designed for different contexts.

But it doesn't have to be this way.

Systems can be designed well. They can be redesigned. They can work.

And the first step is understanding what a system actually is.

Now you do.

Let's build better ones.

---

Henry

Systems Architect. Builder. Problem Solver.

---

P.S. - A Challenge

This week, pick ONE thing that frustrates you—could be anything: slow checkout at the supermarket, terrible customer service at your bank, potholes on your street, whatever.

Map it as a system:

• What's the input?
• What's the process?
• What's the output?
• Why is it producing that output?
• How would you redesign it?

Then share it. Tweet it, post it on LinkedIn, tell a friend.

The more people who understand systems thinking, the more systems we can fix.