"My First Real Agile Project" — plan and run a small real project (school, home, or community) using Agile. Include a backlog, a Kanban board or sprint plan, daily standups, a review, a retrospective, and one tracked metric.
🎯 portfolio piece · peer review · certification
“Agile Fundamentals” – A beginner’s guide to working smarter together
Welcome, young explorer! Have you ever worked on a big project and found it became messy and slow? Have you ever finished something only to discover it was not what anyone wanted? Many people and businesses have this problem. That is why a way of working called Agile was created.
Agile is not a tool or a computer program. It is a way of thinking and working. It helps teams finish tasks faster, change plans easily, and make things people truly want. Agile started with computer programmers, but today it is used by schools, banks, shops, hospitals, and even families.
In this module, we will learn what Agile is, where it came from, and what it stands for. We will learn its four values and twelve principles. We will see how Agile is different from the old way of working. By the end, you will understand why Agile is so popular and how it can help you in school, home, and future work.
Let’s begin!
After finishing this module, you will be able to:
Chidi is 13 years old and lives in Lagos. His teacher gave the class a big group project: build a model of a Nigerian market. The project was due in four weeks.
Chidi’s group chose a plan. They divided the work into steps: research, design, build, and present. They decided to do everything in order. First, they would finish all research. Then, they would design everything. Then, they would build everything. Only at the end would they show the teacher.
Three weeks passed. The group worked hard. On the last day, they showed their model to the teacher. The teacher looked at it and said, "This is not what I asked for. I wanted the market to show how goods move from farms to buyers. Your model just shows shops and stalls."
Chidi’s group was sad. They had worked for weeks but missed the point. They had done everything in one long order and never checked with the teacher until the end.
Another group, led by Ada, did things differently. Ada’s group decided to work in small steps. Each week, they made a small piece of the model and showed it to the teacher. In the first week, the teacher said, "Great start, but add the farm part." In the second week, the teacher said, "Good, now add the transport part." Each week, the group improved and stayed on track.
On the last day, Ada’s group showed a beautiful model that included farms, transport, and shops. The teacher was very happy.
Chidi asked Ada, "How did you get it right?" Ada said, "We did not plan everything at the start. We worked in small steps and checked with the teacher often. That is called Agile."
Chidi learned a big lesson. Working in small steps and checking often is smarter than working a long time without checking.
Moral of the story: Agile means working in small steps, checking often, and improving as you go. It helps you finish projects that people really want.
Definition: Agile is a way of working that helps teams finish projects in small steps, learn as they go, and change plans when needed.
Why it is important: Agile helps teams create better results faster and avoid big mistakes.
Simple explanation: Imagine building a house one room at a time and checking with the owner after each room. That is Agile.
Real-life example: Software companies use Agile to build apps step by step.
School example: A group project done in weekly steps with teacher feedback.
Home example: Cooking a meal and tasting it as you go.
Nigerian example: A trader tests a new product with a few customers before buying in bulk.
Illustration:
Agile = Small Steps + Feedback + Improvement
Plan small
|
V
Do small
|
V
Check with others
|
V
Improve and repeat 🎉
Mini summary: Agile means working in small steps, checking often, and improving. It helps teams succeed.
Definition: Agile started in 2001 when a group of software developers wrote the Agile Manifesto.
Why it is important: Knowing the story helps us understand why Agile matters.
Simple explanation: A group of smart people got together and said, "Our old way is not working. Let’s find a better way."
Real-life example: The same way a school might change its rules after seeing problems.
School example: A teacher changes teaching methods after seeing students struggle.
Home example: A family changes routines after learning what works best.
Nigerian example: A business changes how it serves customers after hearing complaints.
Illustration:
2001: 17 developers meet
|
V
Write the Agile Manifesto
|
V
Share it with the world
|
V
Agile grows everywhere 🎉
Mini summary: Agile began in 2001 with the Agile Manifesto. It was created by software developers.
Definition: Waterfall is a way of working where you do all steps in one long order, one after the other.
Why it is important: Knowing Waterfall helps us see why Agile is better for many projects.
Simple explanation: Like walking down a waterfall. You cannot go back up.
Real-life example: Building a bridge where you plan everything first.
School example: Doing all research, then all writing, then all editing – without stopping to check.
Home example: Cooking all the food before tasting any of it.
Nigerian example: Printing 1,000 flyers before checking if the design is right.
Illustration:
Waterfall: Plan → Design → Build → Test → Deliver (all in one long line, no going back)
Mini summary: Waterfall does everything in one long order. It is hard to change once you start.
Definition: Agile is different because it works in small cycles, checks often, and welcomes change.
Why it is important: Agile helps teams fix problems early and stay on track.
Simple explanation: Instead of one long line, Agile goes in small circles, improving each time.
Real-life example: Software teams release small updates every week.
School example: Group projects checked weekly with the teacher.
Home example: Cooking and tasting in small steps.
Nigerian example: A trader testing small batches before buying in bulk.
Illustration:
Waterfall: Plan → Build → Deliver (once)
Agile: Plan → Do → Check → Improve
↑ |
|________________|
(repeat often) 🎉
Mini summary: Agile works in small cycles. It checks often and improves each time.
Definition: The Agile Manifesto is a short document that explains what Agile values most.
Why it is important: It is the heart of Agile thinking.
Simple explanation: Like a list of promises for how to work well.
Real-life example: Banks that value people and teamwork over strict rules.
School example: A class that values learning and teamwork over just marks.
Home example: A family that values time together over strict schedules.
Nigerian example: A business that values customer happiness over paperwork.
Illustration:
Agile Manifesto: "We value these four things more than the old way."
Mini summary: The Agile Manifesto describes what Agile values most. It has four main values.
Definition: Agile values people and their communication more than strict processes and tools.
Why it is important: Tools do not solve problems. People do.
Simple explanation: A good team with simple tools beats a bad team with fancy tools.
Real-life example: Banks invest in training staff, not just buying software.
School example: A team that talks and helps each other beats one that only follows rules.
Home example: Families that talk openly work better together.
Nigerian example: A market where traders help each other succeeds more than one where nobody talks.
Illustration:
Value 1: People and Interactions > Processes and Tools
Mini summary: Agile values people and communication over tools and rules.
Definition: Agile values working results more than long documents and plans.
Why it is important: A finished product is more useful than a stack of papers.
Simple explanation: A working bicycle is better than a hundred pages about bicycles.
Real-life example: Banks prefer an app that works over a huge design document.
School example: A finished project is better than just a plan.
Home example: A cooked meal is better than just a recipe.
Nigerian example: A trader who sells goods succeeds more than one who only talks about them.
Illustration:
Value 2: Working Results > Documents and Plans
Mini summary: Agile values real, working results over long documents.
Definition: Agile values teamwork with customers more than strict contracts.
Why it is important: When customers are part of the team, the result is better.
Simple explanation: Like working with a friend on a project instead of just following instructions.
Real-life example: Banks work with customers to design apps they love.
School example: Students work with teachers to plan projects.
Home example: Families plan trips together.
Nigerian example: A trader listens to customers and changes products to match their needs.
Illustration:
Value 3: Teamwork with Customers > Strict Contracts
Mini summary: Agile values teamwork with customers over strict contracts.
Definition: Agile values responding to change more than sticking to a fixed plan.
Why it is important: The world changes. Good teams change with it.
Simple explanation: Like changing direction when you see a better path.
Real-life example: Banks change their apps when customers want new features.
School example: Students change their project when the teacher gives new ideas.
Home example: Families change plans when the weather changes.
Nigerian example: A trader changes prices when market conditions change.
Illustration:
Value 4: Responding to Change > Following a Fixed Plan
Mini summary: Agile values responding to change over sticking to a fixed plan.
Definition: The 12 Agile Principles are rules that guide Agile teams.
Why it is important: They turn values into daily actions.
Simple explanation: Like the rules of a game that everyone follows.
Real-life example: Banks use these principles in project planning.
School example: Students use them for group work.
Home example: Families use them in chores.
Nigerian example: Businesses use them for customer service.
Illustration:
Principles 1–4: 1. Satisfy the customer with early and continuous delivery. 2. Welcome changing requirements, even late in the project. 3. Deliver working results frequently. 4. Business people and developers must work together daily.
Mini summary: Principles 1–4 focus on customers, change, frequent delivery, and teamwork.
Definition: The next four principles focus on people and quality.
Why it is important: They keep teams motivated and produce good work.
Simple explanation: Like rules about how to treat your team well.
Real-life example: Banks keep teams small and well-motivated.
School example: Groups have clear roles and trust each other.
Home example: Families share chores fairly.
Nigerian example: Businesses keep teams small and focused.
Illustration:
Principles 5–8: 5. Build projects around motivated people. 6. Face-to-face conversation is the best communication. 7. Working results are the main measure of progress. 8. Agile processes promote sustainable work.
Mini summary: Principles 5–8 focus on motivated teams, talking, real results, and steady pace.
Definition: The last four principles focus on quality and improvement.
Why it is important: They help teams stay excellent and keep getting better.
Simple explanation: Like rules for always improving your work.
Real-life example: Banks review their work every week.
School example: Students review group work and improve.
Home example: Families discuss and improve routines.
Nigerian example: Businesses review customer feedback and improve.
Illustration:
Principles 9–12: 9. Continuous attention to quality. 10. Simplicity – do only what is needed. 11. Best results come from self-organising teams. 12. The team reflects and improves regularly.
Mini summary: Principles 9–12 focus on quality, simplicity, self-organisation, and improvement.
Definition: The Agile mindset is a way of thinking. Agile methods (like Scrum and Kanban) are ways of doing.
Why it is important: You can use Agile methods without the mindset and still fail.
Simple explanation: Mindset is the heart. Methods are the hands.
Real-life example: Banks with the mindset welcome change, not just follow the steps.
School example: A group that truly helps each other is using the mindset.
Home example: A family that listens is using the mindset.
Nigerian example: A business that changes to serve customers better has the mindset.
Illustration:
Mindset: - Trust - Openness - Feedback - Change is good Methods: - Scrum - Kanban - Standups - Sprints
Mini summary: The Agile mindset is a way of thinking. Agile methods are ways of working.
Definition: Mistakes happen. Knowing them helps you avoid them.
Why it is important: Agile can fail if used wrongly.
Simple explanation: Like using a bicycle as a chair – it works, but it is not the point.
Real-life example: Teams that have standups but never improve.
School example: Groups that talk a lot but never finish work.
Home example: Families that plan but never do.
Nigerian example: Businesses that write Agile words but still work the old way.
Table of common mistakes:
| Mistake | What Happens | How to Fix |
|---|---|---|
| Only using ceremonies | No real improvement | Focus on the mindset |
| No customer feedback | Wrong product | Show work often |
| Too many rules | Slows the team | Keep it simple |
| Ignoring feedback | Repeat mistakes | Improve each cycle |
| Fear of change | Stuck with old ideas | Welcome change |
| Big team, no trust | Poor results | Small, trusted team |
Mini summary: Common mistakes: only ceremonies, no feedback, fear of change. Focus on the mindset.
Definition: Best practices are good habits that help Agile work well.
Why it is important: Good habits make Agile feel easy.
Simple explanation: Like training before a race – it makes you ready.
Real-life example: Banks start with small Agile teams first.
School example: Students start with small group projects.
Home example: Families start with one small habit change.
Nigerian example: Businesses start Agile on one product at a time.
List of best practices:
Mini summary: Best practices: start small, work in cycles, get feedback, improve each time.
You now have a strong foundation in Agile thinking.
What you learned:
Next steps: In Module Two, you will learn about Agile teams, roles, and ceremonies.
Illustration:
Your Learning Journey:
Module 1: Foundations
|
V
Module 2: Teams & Ceremonies
|
V
Module 3: Scrum & Kanban
|
V
Module 4: Real Life & Certification
|
V
Agile Expert 🎉
Mini summary: You now understand the basics of Agile. Time to learn how Agile teams work!
| Word | Simple Definition |
|---|---|
| Agile | A way of working in small steps with feedback. |
| Waterfall | The old way of doing everything in one long order. |
| Manifesto | A short document of important ideas. |
| Values | What we believe is most important. |
| Principles | Rules that guide how we work. |
| Cycle | A small round of work and feedback. |
| Mindset | A way of thinking. |
| Method | A way of doing something. |
| Feedback | Comments that help you improve. |
| Self-organising team | A team that plans its own work. |
| Motivated | Feeling excited and ready to work. |
| Continuous | Happening again and again, without stopping. |
| Simplicity | Doing only what is needed. |
| Reflection | Thinking about how to improve. |
| Result | The finished work. |
Waterfall: Plan → Design → Build → Test → Deliver
Agile: Plan → Do → Check → Improve
↑ |
|________________|
Repeat often 🎉
People > Tools Results > Documents Teamwork > Contracts Change > Fixed Plan
Plan → Do → Check → Improve
Mindset: Trust, Openness, Feedback Methods: Scrum, Kanban, Standups
Module 1: Foundations
|
V
Module 2: Teams & Ceremonies
|
V
Module 3: Scrum & Kanban
|
V
Module 4: Real Life & Certification
|
V
Agile Expert 🎉
| Feature | Waterfall | Agile |
|---|---|---|
| Approach | One long order | Many small cycles |
| Change | Hard | Welcome |
| Feedback | At the end | Often |
| Risk | High | Low |
| Best for | Fixed tasks | Changing tasks |
| Feature | Mindset | Methods |
|---|---|---|
| Type | Way of thinking | Way of doing |
| Examples | Trust, feedback | Scrum, Kanban |
| Importance | Very high | Useful |
| # | Value More | Value Less |
|---|---|---|
| 1 | People and interactions | Processes and tools |
| 2 | Working results | Documents and plans |
| 3 | Teamwork with customers | Strict contracts |
| 4 | Responding to change | Fixed plan |
| Feature | Without Agile | With Agile |
|---|---|---|
| Feedback | Late | Often |
| Change | Hard | Easy |
| Teamwork | Less | More |
| Result quality | Varies | Higher |
Lesson 1: Agile means working in small steps with feedback.
Lesson 2: Agile began in 2001 with the Agile Manifesto.
Lesson 3: Waterfall does everything in one long order.
Lesson 4: Agile works in small cycles and improves each time.
Lesson 5: The Agile Manifesto describes what Agile values.
Lesson 6: Agile values people over tools.
Lesson 7: Agile values working results over long documents.
Lesson 8: Agile values teamwork with customers over strict contracts.
Lesson 9: Agile values responding to change over fixed plans.
Lesson 10: Principles 1–4 focus on customers, change, delivery, teamwork.
Lesson 11: Principles 5–8 focus on motivation, talking, results, pace.
Lesson 12: Principles 9–12 focus on quality, simplicity, self-organisation, improvement.
Lesson 13: Mindset is a way of thinking; methods are ways of doing.
Lesson 14: Common mistakes: only ceremonies, no feedback.
Lesson 15: Best practices: start small, work in cycles, improve often.
Lesson 16: You now have a strong Agile foundation.
Congratulations! You have finished Module One of the Agile Fundamentals course. You learned what Agile is and why it matters. You learned where Agile came from and what Waterfall is. You learned the 4 Agile values and the 12 Agile principles. You learned the difference between an Agile mindset and Agile methods. You learned common mistakes and best practices. Most importantly, you now understand that Agile means working in small steps, checking often, and improving as you go. In the next module, you will learn about Agile teams, roles, and ceremonies. Keep learning, and you will become an Agile expert!
Match the term to its meaning.
| Term | Meaning |
|---|---|
| 1. Agile | A. Old way of working in one long order |
| 2. Waterfall | B. A way of thinking |
| 3. Manifesto | C. Working in small steps with feedback |
| 4. Mindset | D. A short document of big ideas |
| 5. Method | E. A way of doing, like Scrum |
Answers: 1-C, 2-A, 3-D, 4-B, 5-E
Title: “Agile vs Waterfall Together”
Instructions: In groups of 3–4, choose a small task (like planning a class party). Split into two groups: one plans in Waterfall style, one in Agile style. Then compare: Which group finished faster? Which got better feedback? Which would you use again? Present your findings to the class.
Goal: Experience the difference between Agile and Waterfall.
Task: Choose a small personal task (like cleaning your room or writing an essay). Then:
Hint: Notice how checking and improving changes the work.
Project: “My Agile Mini Plan”
Choose a small project at home or school. Then create an Agile plan with:
Example:
Project: Build a family budget tracker Values: People, results, teamwork, change Steps: Week 1 gather income; Week 2 add expenses; Week 3 review Feedback: Show family each week Improve: Add categories they ask for Celebrate: Family pizza night 🎉
Assignment: Interview a teacher, parent, or family friend. Ask them:
Then write a one-page report connecting their answers to Agile values and principles.
Submit: Your report with at least three Agile ideas.
In Module Two, we will learn about Agile teams, roles, and ceremonies. We will cover:
To prepare, complete the practical assignment and bring your Agile mini plan. Review the key vocabulary. Think about what makes a great team. Bring your curiosity!
See you in Module Two!
End of Module One – Agile Fundamentals
“Agile Fundamentals” – A beginner’s guide to working smarter together
Welcome back, young Agile explorer! In Module One, you learned what Agile is, where it came from, and what it values. You learned the 4 values and the 12 principles. You learned that Agile means working in small steps, checking often, and improving as you go.
Now it is time to meet the people behind Agile. In Module Two, we will learn about Agile teams, roles, and ceremonies. A team is a group of people working together. A role is the job each person does. A ceremony is a special meeting that Agile teams hold regularly.
Think of an Agile team as a football team. Everyone has a position, and they meet often to talk, plan, and improve. Without a good team, great ideas never become reality. In this module, we will learn how Agile teams are built, how they talk, and how they improve every week.
By the end of this module, you will know how to describe an Agile team, run simple Agile meetings, and help any group work better together.
Let’s begin!
After finishing this module, you will be able to:
Ada is 14 years old and lives in Enugu. Her school entered a national debate competition. The teacher chose five students: Ada, Chidi, Ngozi, Tunde, and Emeka. They had three weeks to prepare.
At first, the team was confused. Nobody knew who was doing what. Chidi wanted to write all the speeches. Ngozi wanted to do all the research. Tunde and Emeka argued about who would speak first. Ada felt lost.
Then Ada remembered what she learned in Module One. She said, "Let’s work like an Agile team. Let’s choose clear roles, talk every day, and improve as we go."
The team agreed. They chose roles:
Every morning, the team held a "daily standup." They stood in a circle and each person answered three questions:
The standup took only 10 minutes, but it helped the team stay on track.
At the end of each week, they did a "sprint review." They practised their debate in front of their teacher. The teacher gave feedback. Then they did a "retrospective" – they asked: What went well? What could be better? What will we change?
After three weeks, the team was amazing. They won second place in the competition. But more importantly, they learned how to work as a real Agile team.
Moral of the story: Agile teams have clear roles, meet often, and improve together. Standups, reviews, and retrospectives help teams win.
Definition: An Agile team is a small group of people who work together in short cycles to deliver results.
Why it is important: Agile teams are the heart of Agile work.
Simple explanation: Imagine a small group of friends working on a project and checking with each other every day. That is an Agile team.
Real-life example: A software team building an app together.
School example: A debate team preparing for a competition.
Home example: A family planning a birthday party.
Nigerian example: A group of traders planning a market day together.
Illustration:
Agile Team:
+-------+ +-------+ +-------+
| Person| | Person| | Person|
+-------+ +-------+ +-------+
| | |
+----------+----------+
|
Working Together 🎉
Mini summary: An Agile team is a small group that works together in short cycles.
Definition: Agile teams are usually small – often 5 to 9 people.
Why it is important: Small teams talk more easily and move faster.
Simple explanation: Like a small group of friends planning a trip. It is easier than planning with 50 people.
Real-life example: Banks keep teams small so they can decide quickly.
School example: Group projects work best with 4–5 students.
Home example: A family of four can plan faster than a family of twenty.
Nigerian example: A small trader team can adjust prices faster than a big market association.
Illustration:
Small Team: Big Team: Fast talking Slow talking Easy decisions Many arguments Quick changes Hard to change
Mini summary: Agile teams are small. Small teams talk and decide faster.
Definition: A cross-functional team has people with different skills who can cover all parts of the work.
Why it is important: The team does not need to wait for outside help.
Simple explanation: Like a football team with a goalkeeper, defenders, midfielders, and strikers. Everyone has a role.
Real-life example: A bank team with a developer, a designer, and a tester.
School example: A group with a writer, a researcher, and a presenter.
Home example: A family with a cook, a cleaner, and a shopper.
Nigerian example: A team of traders with a cook, a seller, and a driver.
Illustration:
Cross-Functional Team: Writer + Researcher + Presenter = Complete Team 🎉
Mini summary: Cross-functional teams have different skills. They can handle all parts of the work.
Definition: Agile teams usually have three main roles: Product Owner, Scrum Master, and Team.
Why it is important: Clear roles prevent confusion.
Simple explanation: Like different jobs in a school play – director, stage manager, and actors.
Real-life example: Banks use these roles in every Agile project.
School example: A group project with a leader, a helper, and workers.
Home example: A family with a planner, an organiser, and helpers.
Nigerian example: A market group with a lead trader, an organiser, and sellers.
Illustration:
Common Agile Roles:
+-----------------+ +-----------------+ +-----------------+
| Product Owner | | Scrum Master | | Team |
+-----------------+ +-----------------+ +-----------------+
What to build? Helps and removes Builds the work
blockers
Mini summary: Agile teams have three main roles: Product Owner, Scrum Master, and Team.
Definition: The Product Owner decides what the team should build and in what order.
Why it is important: Without this role, the team might build the wrong thing.
Simple explanation: Like the captain of a team who chooses the game plan.
Real-life example: Banks have Product Owners to prioritise features.
School example: A project leader who decides what to do first.
Home example: A parent who decides what chores are most important.
Nigerian example: A shop owner who decides which products to stock first.
Illustration:
Product Owner: Decides: - What to build - What is most important - What comes first
Mini summary: The Product Owner decides what the team builds and in what order.
Definition: The Scrum Master helps the team work smoothly and removes obstacles.
Why it is important: They keep the team moving forward.
Simple explanation: Like a coach who helps players do their best.
Real-life example: Banks use Scrum Masters to keep teams on track.
School example: A team helper who makes sure everyone can work.
Home example: A sibling who helps solve family problems.
Nigerian example: A group organiser who helps traders solve disputes.
Illustration:
Scrum Master: - Helps the team - Removes blockers - Keeps meetings on track - Protects the team
Mini summary: The Scrum Master helps the team and removes blockers.
Definition: The Development Team does the work – building, testing, and delivering.
Why it is important: Without them, nothing gets made.
Simple explanation: Like the players in a football match.
Real-life example: Banks have developers, designers, and testers in the team.
School example: The students who write, research, and present.
Home example: Family members who cook, clean, and shop.
Nigerian example: Traders who sell, pack, and deliver goods.
Illustration:
Development Team: - Build the work - Test the work - Deliver the work
Mini summary: The Development Team does the real work.
Definition: A ceremony is a special meeting Agile teams hold regularly.
Why it is important: Ceremonies keep the team aligned and improving.
Simple explanation: Like a class assembly. It keeps everyone informed.
Real-life example: Banks hold weekly ceremonies for every team.
School example: Teachers hold daily class meetings.
Home example: Families have dinner together to talk.
Nigerian example: Traders meet at the market each morning.
Illustration:
Common Agile Ceremonies: - Daily Standup - Sprint Planning - Sprint Review - Retrospective
Mini summary: Ceremonies are special meetings. They keep the team aligned.
Definition: The daily standup is a short meeting where everyone shares progress and blockers.
Why it is important: It keeps the team connected every day.
Simple explanation: Like a quick group chat each morning.
Real-life example: Banks do standups in 15 minutes.
School example: Groups check in for 10 minutes.
Home example: Families plan the day at breakfast.
Nigerian example: Traders greet each other before opening stalls.
Illustration:
Daily Standup: Three Questions: 1. What did I do yesterday? 2. What will I do today? 3. What is blocking me?
Step-by-step:
Mini summary: A daily standup is short. It keeps the team up to date.
Definition: Sprint Planning is a meeting where the team chooses what to do in the next short cycle (a sprint).
Why it is important: It gives the team clear goals.
Simple explanation: Like planning your week before it starts.
Real-life example: Banks plan sprints every two weeks.
School example: Groups plan what to do next week.
Home example: Families plan their weekend.
Nigerian example: Traders plan what to buy for the next market day.
Illustration:
Sprint Planning: Sprint Goal + List of Tasks = Ready to Work 🎉
Step-by-step:
Mini summary: Sprint Planning chooses what to do next. It gives the team a clear goal.
Definition: Sprint Review is a meeting where the team shows the finished work to users or customers.
Why it is important: Feedback from users makes the work better.
Simple explanation: Like a school show-and-tell after finishing a project.
Real-life example: Banks show new app features to customers.
School example: Students show their project to the teacher.
Home example: Family shows a new meal to relatives.
Nigerian example: A trader shows new products to customers.
Illustration:
Sprint Review: Team shows work → Users give feedback → Team improves
Step-by-step:
Mini summary: Sprint Review shows finished work to users. Feedback makes it better.
Definition: A retrospective is a meeting where the team talks about what went well and what to improve.
Why it is important: Teams get better by talking honestly.
Simple explanation: Like a family meeting about the past week.
Real-life example: Banks hold retrospectives every sprint.
School example: Groups discuss what worked after a project.
Home example: Families talk about what went well on a trip.
Nigerian example: Traders discuss how to improve after each market day.
Illustration:
Retrospective: - What went well? - What went wrong? - What will we change?
Step-by-step:
Mini summary: A retrospective helps teams improve. Ask the three questions.
Definition: A working agreement is a short list of rules the team makes for itself.
Why it is important: Agreements prevent confusion and arguments.
Simple explanation: Like class rules, but made by the class itself.
Real-life example: Banks have team rules about meetings and communication.
School example: Groups agree on when to meet and who does what.
Home example: Families agree on chores and quiet times.
Nigerian example: Traders agree on prices and shared services.
Illustration:
Working Agreement Examples: - We start meetings on time. - We speak one at a time. - We ask for help when stuck. - We finish what we start. - We give kind feedback.
Step-by-step:
Mini summary: Working agreements are team-made rules. They prevent confusion.
Definition: Mistakes happen. Knowing them helps you avoid them.
Why it is important: Agile teams can fail if they use the wrong habits.
Simple explanation: Like a team that talks but never plays.
Real-life example: Banks that only follow the steps and forget the mindset.
School example: Groups that meet but never get work done.
Home example: Families that plan but forget to act.
Nigerian example: Businesses that use Agile words but work the old way.
Table of common mistakes:
| Mistake | What Happens | How to Fix |
|---|---|---|
| Standups too long | Team loses focus | Keep them under 15 minutes |
| No clear roles | Confusion | Assign roles early |
| Skipping retrospectives | No improvement | Hold them every cycle |
| Fear of speaking up | Problems grow | Make it safe to share |
| Too big a team | Slow decisions | Keep 5–9 people |
| No working agreement | Arguments | Make rules together |
Mini summary: Common mistakes: long standups, no roles, skipping retrospectives. Fix them early.
Definition: Best practices are good habits that help Agile teams succeed.
Why it is important: Good habits make the team strong.
Simple explanation: Like brushing your teeth every day – it keeps things healthy.
Real-life example: Banks train their Agile teams on best practices.
School example: Groups follow rules and help each other.
Home example: Families talk openly and share chores.
Nigerian example: Businesses keep teams small and focused.
List of best practices:
Mini summary: Best practices: small teams, clear roles, short meetings, and trust.
You now know how Agile teams work.
What you learned:
Next steps: In Module Three, you will learn about Scrum, Kanban, and common Agile frameworks.
Illustration:
Your Learning Journey:
Module 1: Foundations
|
V
Module 2: Teams & Ceremonies
|
V
Module 3: Scrum & Kanban
|
V
Module 4: Real Life & Certification
|
V
Agile Expert 🎉
Mini summary: You now understand Agile teams and ceremonies. Time to explore frameworks!
| Word | Simple Definition |
|---|---|
| Agile Team | A small group working in short cycles. |
| Cross-functional | Having many skills in one team. |
| Role | The job a person does. |
| Product Owner | Decides what to build and when. |
| Scrum Master | Helps the team and removes blockers. |
| Development Team | Does the work. |
| Ceremony | A regular Agile meeting. |
| Standup | A short daily meeting. |
| Sprint | A short working cycle. |
| Sprint Planning | A meeting to plan the sprint. |
| Sprint Review | A meeting to show work to users. |
| Retrospective | A meeting to improve the team. |
| Blocker | Something stopping the work. |
| Working Agreement | Rules made by the team. |
| Trust | Believing in each other. |
+-----------------+ +-----------------+ +-----------------+ | Product Owner | | Scrum Master | | Team | +-----------------+ +-----------------+ +-----------------+ Decides "what" Removes blockers Does the work
Plan → Work → Review → Retrospect
↑ |
|__________________________|
Three Questions: 1. What did I do yesterday? 2. What will I do today? 3. What is blocking me?
- Start on time - Speak one at a time - Ask for help - Finish what we start
Module 1: Foundations
|
V
Module 2: Teams & Ceremonies
|
V
Module 3: Scrum & Kanban
|
V
Module 4: Real Life & Certification
|
V
Agile Expert 🎉
| Feature | Product Owner | Scrum Master |
|---|---|---|
| Focus | What to build | How the team works |
| Talks to | Users and business | Team and leaders |
| Best at | Prioritising | Removing blockers |
| Feature | Standup | Sprint Review |
|---|---|---|
| Frequency | Daily | End of sprint |
| Length | 10–15 min | 30–60 min |
| Who joins | Team | Team + users |
| Feature | Retrospective | Sprint Review |
|---|---|---|
| Focus | Team improvement | Product feedback |
| Who joins | Team only | Team + users |
| Output | Changes to try | New ideas |
| Feature | Big Team | Small Team |
|---|---|---|
| Decisions | Slow | Fast |
| Talking | Hard | Easy |
| Change | Hard | Easy |
Lesson 1: An Agile team is a small group working in short cycles.
Lesson 2: Small teams talk and decide faster.
Lesson 3: Cross-functional teams have many skills.
Lesson 4: Agile has three main roles.
Lesson 5: The Product Owner decides what to build.
Lesson 6: The Scrum Master helps and removes blockers.
Lesson 7: The Team does the real work.
Lesson 8: Ceremonies are regular Agile meetings.
Lesson 9: Standups are short and daily.
Lesson 10: Sprint planning sets the goal.
Lesson 11: Sprint reviews show work to users.
Lesson 12: Retrospectives improve the team.
Lesson 13: Working agreements prevent confusion.
Lesson 14: Common mistakes: long standups, no roles.
Lesson 15: Best practices: small teams, clear roles, trust.
Lesson 16: You now understand Agile teams and ceremonies.
Congratulations! You have finished Module Two of the Agile Fundamentals course. You learned what an Agile team is and why small teams work better. You learned what cross-functional teams are and the three main roles: Product Owner, Scrum Master, and Development Team. You learned about common Agile ceremonies: standups, sprint planning, sprint reviews, and retrospectives. You learned what working agreements are and how they help. You learned common mistakes and best practices. Most importantly, you now know how Agile teams work together, talk often, and improve every cycle. In the next module, you will learn about Scrum, Kanban, and other common Agile frameworks. Keep learning, and you will become an Agile expert!
Match the term to its meaning.
| Term | Meaning |
|---|---|
| 1. Product Owner | A. Short daily meeting |
| 2. Scrum Master | B. Decides what to build |
| 3. Standup | C. Team-made rules |
| 4. Retrospective | D. Helps and removes blockers |
| 5. Working Agreement | E. Meeting to improve the team |
Answers: 1-B, 2-D, 3-A, 4-E, 5-C
Title: “Run an Agile Team Together”
Instructions: In groups of 4–5, choose a small task (like planning a class event). Assign roles (Product Owner, Scrum Master, Team). Write a working agreement. Run one standup with the three questions. Plan one sprint. Present to the class how it went.
Goal: Experience Agile team roles and ceremonies.
Task: Choose a small task at home or school. Then:
Hint: Keep it short and clear.
Project: “My Agile Team Plan”
Create a one-page plan for a small Agile team:
Example:
Team: Class Project Squad Purpose: Build a class magazine Roles: Ada (PO), Chidi (SM), Ngozi, Tunde, Emeka (Team) Agreements: Start on time; one speaker at a time; help when stuck. Sprint Goal: Finish first draft of all articles. Standup: Every day at 4pm. Review: Show magazine to teacher Friday. Retro: Discuss after review. Celebrate: Pizza with team 🎉
Assignment: Choose a group you belong to (school, family, club). Then:
Submit: A one-page report with your plan and experience.
In Module Three, we will explore Scrum, Kanban, and common Agile frameworks. We will cover:
To prepare, complete the practical assignment and bring your Agile team plan. Review the key vocabulary. Think about which framework (Scrum or Kanban) might suit your group. Bring your curiosity!
See you in Module Three!
End of Module Two – Agile Fundamentals
“Agile Fundamentals” – A beginner’s guide to working smarter together
Welcome back, young Agile explorer! In Module One, you learned what Agile is – its values and principles. In Module Two, you learned how Agile teams work – their roles and ceremonies like standups, sprint planning, reviews, and retrospectives.
Now it is time to explore the frameworks – the actual methods that teams use to apply Agile. The two most popular frameworks are Scrum and Kanban. A framework is like a recipe. It tells you what steps to follow. Scrum and Kanban are two different recipes for working in an Agile way.
Think of it like this: Agile is the idea of "cooking healthy meals". Scrum and Kanban are two different ways to plan, cook, and serve those meals. One is more structured (Scrum). One is more flexible (Kanban). Both work well.
In this module, we will learn about Scrum and Kanban in simple language. We will learn about backlogs, user stories, estimation, prioritisation, velocity, and flow. By the end, you will be able to choose the right framework for your team.
Let’s begin!
After finishing this module, you will be able to:
Ngozi is 14 years old and lives in Ibadan. Her family owns two small bakeries. One bakery is called "Bread Sprint". The other is called "Bread Flow".
Ngozi noticed that the two bakeries worked differently.
At Bread Sprint, the bakers worked in two-week cycles. At the start of each cycle, they chose a small list of things to bake: "This cycle we will bake 100 loaves of bread, 50 meat pies, and 30 cakes." They called this list their "sprint backlog".
Every morning, the bakers held a standup. They answered three questions. They had a "Product Owner" who decided what to bake next. They had a "Scrum Master" who helped remove problems.
At the end of two weeks, they reviewed what they baked and improved for the next cycle. This worked very well. Bread Sprint always finished its goals on time.
At Bread Flow, the bakers worked differently. They had one big list of things to bake – not split into cycles. They called this list "the board". The board had three columns: "To Bake", "Baking", and "Done". As bread moved through the bakery, it moved across the board.
The bakers at Bread Flow did not work in cycles. They just kept the bread flowing. They had a rule: "No more than three loaves in the 'Baking' column at once." If the column was full, they could not start another loaf until one moved to "Done". This stopped them from being overloaded.
Bread Flow was very flexible. If a customer ordered 20 cakes suddenly, they could add it to the board right away.
Ngozi asked her mother, "Which bakery is better?" Her mother said, "Both are good. Bread Sprint is better for planned work. Bread Flow is better for changing work. It depends on what the bakery needs."
Ngozi understood. She learned that Scrum and Kanban are two ways to do Agile. Each fits different situations.
Moral of the story: Scrum works in cycles with clear goals. Kanban works with a flowing board and limits work in progress. Both are good – choose the one that fits your task.
Definition: An Agile framework is a set of rules and practices for using Agile.
Why it is important: Frameworks help teams apply Agile in a structured way.
Simple explanation: Like a recipe for baking a cake. Follow the steps, and you get a good result.
Real-life example: Banks use Scrum and Kanban as frameworks.
School example: A group project can use Scrum or Kanban.
Home example: Families plan chores using Scrum or Kanban.
Nigerian example: Traders use Kanban for daily market tasks.
Illustration:
Agile = Idea Frameworks = Recipes Scrum Kanban Others
Mini summary: Agile frameworks are recipes for working in an Agile way. Scrum and Kanban are the most popular.
Definition: Scrum is an Agile framework where teams work in short cycles called sprints.
Why it is important: Scrum gives teams clear structure and goals.
Simple explanation: Like working in two-week "seasons" with a clear goal for each season.
Real-life example: Banks use Scrum to build new app features.
School example: Groups work in weekly cycles to finish a project.
Home example: Families plan two-week projects like repainting a room.
Nigerian example: A trader runs a two-week sprint to prepare for a big market day.
Illustration:
Scrum Sprints: Sprint 1 → Sprint 2 → Sprint 3 (2 weeks) (2 weeks) (2 weeks)
Mini summary: Scrum works in short cycles called sprints. Each sprint has a clear goal.
Definition: Kanban is an Agile framework that uses a visual board to track work flowing through stages.
Why it is important: Kanban helps teams see what is happening and avoid overload.
Simple explanation: Like a board with columns: To Do, Doing, Done.
Real-life example: Banks use Kanban for customer support tickets.
School example: Groups use a Kanban board for homework tasks.
Home example: Families use a Kanban board for chores.
Nigerian example: A tailor uses Kanban for tailoring orders.
Illustration:
Kanban Board: +--------+ +--------+ +--------+ | To Do | | Doing | | Done | +--------+ +--------+ +--------+ | Task A | | Task C | | Task E | | Task B | | Task D | | | +--------+ +--------+ +--------+
Mini summary: Kanban uses a visual board to track work. It shows what is happening at a glance.
Definition: A backlog is a list of all the work that needs to be done.
Why it is important: A backlog keeps work organised and visible.
Simple explanation: Like a shopping list of everything you need to buy.
Real-life example: Banks keep a backlog of app features.
School example: Groups list all tasks for a project.
Home example: Families keep a backlog of chores.
Nigerian example: Traders list all goods to restock.
Illustration:
Backlog Example: 1. Design homepage 2. Add login button 3. Test on phones 4. Write help page
Mini summary: A backlog is a list of all work. It keeps the team organised.
Definition: The Product Backlog is the full list. The Sprint Backlog is the small list chosen for one sprint.
Why it is important: Splitting the big list makes work manageable.
Simple explanation: Like a full shopping list (Product Backlog) and today’s short list (Sprint Backlog).
Real-life example: Banks keep a product backlog of all features.
School example: Groups choose three tasks for the week.
Home example: Families pick today’s chores from a big list.
Nigerian example: Traders choose today’s goods from a big stock list.
Illustration:
Product Backlog: Sprint Backlog: - 20 items total - 3 items this sprint Big list → Small list
Mini summary: The Product Backlog is the full list. The Sprint Backlog is the short list for one sprint.
Definition: A user story is a short description of something a user wants.
Why it is important: User stories keep work focused on real needs.
Simple explanation: Like writing: "As a student, I want a study plan so I can pass my exams."
Real-life example: Banks write user stories for customers.
School example: Groups write user stories for teachers.
Home example: Families write stories like "As a family, we want a simple chore chart."
Nigerian example: A trader writes: "As a customer, I want to order by WhatsApp."
Illustration:
User Story Format: As a [user], I want [something], So that [reason]. Example: As a student, I want a study plan, so that I pass my exams.
Mini summary: User stories describe what users want. They follow a simple format.
Definition: Estimation means guessing how big or long a task will take.
Why it is important: It helps teams plan how much work fits in a sprint.
Simple explanation: Like guessing: "This homework is small, this one is big."
Real-life example: Banks estimate story points for features.
School example: Groups estimate time per subject.
Home example: Families estimate time for chores.
Nigerian example: Traders estimate how long a delivery will take.
Illustration:
Estimation Example: Small: 1 point (quick task) Medium: 3 points (few hours) Large: 5 points (a full day) XL: 8 points (too big — split it)
Mini summary: Estimation guesses the size of tasks. It helps plan sprints.
Definition: Prioritisation means deciding which tasks to do first.
Why it is important: You cannot do everything at once.
Simple explanation: Like packing the most important items first when travelling.
Real-life example: Banks prioritise features customers need most.
School example: Students do the most urgent homework first.
Home example: Families do urgent chores first.
Nigerian example: Traders prioritise fast-selling goods.
Illustration:
Prioritisation Example: High: Pay rent today Medium: Buy food this week Low: Watch a movie Do high first!
Mini summary: Prioritisation means choosing what to do first. Do the most important tasks early.
Definition: Velocity is how much work a team finishes in one sprint.
Why it is important: Velocity helps teams plan how much to take on.
Simple explanation: Like measuring how many laps a runner runs in 10 minutes.
Real-life example: Banks track velocity to predict future work.
School example: Groups track how many tasks they finish per week.
Home example: Families track how many chores get done on weekends.
Nigerian example: Traders track how many orders are delivered per day.
Illustration:
Velocity: Sprint 1: 20 points Sprint 2: 22 points Sprint 3: 21 points Average: 21 points per sprint
Mini summary: Velocity is how much work a team finishes in a sprint. It helps plan future sprints.
Definition: Flow is how smoothly work moves from start to finish.
Why it is important: Good flow means fast delivery.
Simple explanation: Like water flowing through a pipe. No blockages.
Real-life example: Banks track flow in customer service queues.
School example: Groups track flow in group work.
Home example: Families track flow of chores.
Nigerian example: Traders track flow of orders from customer to delivery.
Illustration:
Flow Example: Good flow: Bad flow: Task → Task → Done Task → Stuck → Stuck → Done (fast!) (slow!)
Mini summary: Flow shows how smooth the work is. Good flow means fast delivery.
Definition: A WIP limit is a rule that says how many tasks can be "in progress" at once.
Why it is important: Too many tasks at once slows everything down.
Simple explanation: Like cooking. Too many pots at once makes a mess.
Real-life example: Banks limit open tickets per agent.
School example: Groups limit how many tasks to work on at once.
Home example: Families limit chores in progress.
Nigerian example: Traders limit open deliveries in one day.
Illustration:
WIP Limit Example: To Do Doing (max 3) Done Task A Task C Task B Task D Task E Task F New task waits until one moves to Done.
Mini summary: WIP limits stop teams from doing too much at once. It keeps flow smooth.
Definition: Scrum and Kanban are both Agile frameworks but work differently.
Why it is important: Knowing the difference helps you choose the right one.
Simple explanation: Scrum is like a relay race (batches). Kanban is like a flowing river (continuous).
Real-life example: Banks use Scrum for new projects and Kanban for support.
School example: Groups use Scrum for projects and Kanban for homework.
Home example: Families use Scrum for big events and Kanban for daily chores.
Nigerian example: Traders use Scrum for big market seasons and Kanban for daily selling.
Illustration:
Scrum: Kanban: Sprint 1 To Do → Doing → Done Sprint 2 Continuous flow Sprint 3 (cycles) (continuous)
Mini summary: Scrum works in cycles. Kanban works continuously. Choose based on your task.
Definition: Agile has many frameworks besides Scrum and Kanban.
Why it is important: Different teams need different tools.
Simple explanation: Like different tools in a toolbox.
Real-life example: Banks use SAFe for large teams.
School example: Groups can use Scrumban (a mix).
Home example: Families can invent their own style.
Nigerian example: Businesses choose frameworks that fit their size.
Illustration:
Other Agile Frameworks: - Scrumban (Scrum + Kanban) - XP (Extreme Programming) - SAFe (Scaled Agile Framework) - Lean - Crystal
Mini summary: Many Agile frameworks exist. Choose one that fits your team size and task.
Definition: Mistakes happen. Knowing them helps you avoid them.
Why it is important: Using the wrong framework or misusing it hurts the team.
Simple explanation: Like using a hammer for screws. It works, but not well.
Real-life example: Banks sometimes over-complicate Scrum.
School example: Groups follow steps without understanding.
Home example: Families copy routines that do not fit.
Nigerian example: Businesses use Agile words but work the old way.
Table of common mistakes:
| Mistake | What Happens | How to Fix |
|---|---|---|
| Choosing the wrong framework | Extra work | Match framework to task |
| No clear sprint goal | Confusion | Set a goal every sprint |
| Too many WIP items | Slow flow | Set WIP limits |
| Ignoring backlog order | Wrong work first | Prioritise clearly |
| No estimation | Overload | Estimate tasks |
| Following rules blindly | No real Agile | Understand the mindset |
Mini summary: Common mistakes: wrong framework, no goal, too many tasks. Fix them early.
Definition: Best practices help you pick and use the right framework.
Why it is important: A good fit makes work easier.
Simple explanation: Like choosing the right shoes for the right activity.
Real-life example: Banks use Scrum for big projects and Kanban for support.
School example: Groups pick Scrumban for mixed work.
Home example: Families pick a simple board for chores.
Nigerian example: Businesses start simple and improve.
List of best practices:
Mini summary: Best practices: keep it simple, match framework to task, improve each cycle.
You now know how to use Scrum and Kanban.
What you learned:
Next steps: In Module Four, you will apply Agile in real life and complete your certification project.
Illustration:
Your Learning Journey:
Module 1: Foundations
|
V
Module 2: Teams & Ceremonies
|
V
Module 3: Scrum & Kanban
|
V
Module 4: Real Life & Certification
|
V
Agile Expert 🎉
Mini summary: You now know Scrum and Kanban. Time to use Agile in real life!
| Word | Simple Definition |
|---|---|
| Framework | A recipe for working. |
| Scrum | An Agile framework with sprints. |
| Sprint | A short working cycle. |
| Kanban | An Agile framework with a board. |
| Board | A visual list of tasks. |
| Backlog | A list of all work. |
| Product Backlog | The full list of work. |
| Sprint Backlog | The short list for one sprint. |
| User Story | A short description of a user need. |
| Estimation | Guessing the size of a task. |
| Prioritisation | Deciding what to do first. |
| Velocity | Work finished per sprint. |
| Flow | How smooth work moves. |
| WIP Limit | A rule on how many tasks can be active. |
| Scrumban | A mix of Scrum and Kanban. |
Sprint 1 → Sprint 2 → Sprint 3 (2 weeks) (2 weeks) (2 weeks)
+--------+ +--------+ +--------+ | To Do | | Doing | | Done | +--------+ +--------+ +--------+ | Task A | | Task C | | Task E | | Task B | | Task D | | | +--------+ +--------+ +--------+
As a [user], I want [something], So that [reason].
Doing (max 3): Task C Task D Task F New task waits until one moves to Done.
Module 1: Foundations
|
V
Module 2: Teams & Ceremonies
|
V
Module 3: Scrum & Kanban
|
V
Module 4: Real Life & Certification
|
V
Agile Expert 🎉
| Feature | Scrum | Kanban |
|---|---|---|
| Cycles | Sprints | Continuous |
| Board | Sprint board | Flow board |
| Roles | PO, SM, Team | Optional |
| Change | Between sprints | Any time |
| Best for | Planned work | Changing work |
| Feature | Product Backlog | Sprint Backlog |
|---|---|---|
| Size | Big list | Small list |
| Time | Long-term | Current sprint |
| Owner | Product Owner | Team |
| Feature | Velocity | Flow |
|---|---|---|
| Measures | Work per sprint | How smooth work moves |
| Best for | Planning | Improving |
| Used in | Scrum | Kanban |
| Feature | Scrum | Scrumban |
|---|---|---|
| Cycles | Fixed sprints | Flexible |
| Board | Sprint board | Flow board with WIP |
| Best for | Clear goals | Mixed work |
Lesson 1: Agile frameworks are recipes for working.
Lesson 2: Scrum works in short cycles called sprints.
Lesson 3: Kanban uses a visual board for flow.
Lesson 4: A backlog is a list of all work.
Lesson 5: Product Backlog is the full list; Sprint Backlog is the short list.
Lesson 6: User stories describe user needs.
Lesson 7: Estimation guesses the size of tasks.
Lesson 8: Prioritisation decides what to do first.
Lesson 9: Velocity is work done per sprint.
Lesson 10: Flow shows how smooth the work is.
Lesson 11: WIP limits keep flow smooth.
Lesson 12: Scrum works in cycles; Kanban flows continuously.
Lesson 13: Other frameworks include Scrumban, XP, SAFe.
Lesson 14: Common mistakes: wrong framework, no goal.
Lesson 15: Best practices: simple, matched, reviewed.
Lesson 16: You now know Scrum and Kanban.
Congratulations! You have finished Module Three of the Agile Fundamentals course. You learned what an Agile framework is. You learned Scrum and Kanban in simple language. You learned about backlogs, user stories, estimation, prioritisation, velocity, flow, and WIP limits. You learned how Scrum and Kanban compare and when to use each. You learned about other frameworks like Scrumban, XP, and SAFe. You learned common mistakes and best practices. Most importantly, you can now choose the right framework for a task and use it to work smarter. In the next module, you will apply Agile to real life and complete your certification project. Keep learning, and you will become an Agile expert!
Match the term to its meaning.
| Term | Meaning |
|---|---|
| 1. Scrum | A. A visual board for flow |
| 2. Kanban | B. A list of all work |
| 3. Backlog | C. Work finished per sprint |
| 4. Velocity | D. An Agile framework with sprints |
| 5. WIP Limit | E. A rule on active tasks |
Answers: 1-D, 2-A, 3-B, 4-C, 5-E
Title: “Scrum or Kanban – You Choose”
Instructions: In groups of 3–4, choose a small project. First plan with Scrum (sprint goal, backlog, estimation). Then plan with Kanban (board, WIP limits). Compare which fits better. One person writes Scrum, one writes Kanban, one compares, and one presents. Share with the class.
Goal: Experience Scrum and Kanban in the same project.
Task: Choose a personal task list (home or school). Then:
Hint: Keep it small and clear.
Project: “My First Scrum or Kanban Board”
Create a plan for a two-week project using Scrum or Kanban. Include:
Example:
Project: My Study Plan for Exams Framework: Kanban Columns: To Do | Doing (max 2) | Done User Story: As a student, I want notes summarised, so I revise faster. Estimation: Small (1) to Large (5). Review: Every Sunday. Retrospective: Every Sunday after review.
Assignment: Pick a real group (family, school club, or small business). Then:
Submit: Your report with a screenshot or sketch of your board/backlog.
In Module Four, we will apply Agile in real life and complete the certification project. We will cover:
To prepare, complete the practical assignment and bring your board or backlog. Review the key vocabulary. Think about a real project where you would like to use Scrum or Kanban. Bring your curiosity!
See you in Module Four!
End of Module Three – Agile Fundamentals
“Agile Fundamentals” – A beginner’s guide to working smarter together
Welcome to the final module, young Agile expert! You have come a very long way. In Module One, you learned what Agile is. In Module Two, you learned about Agile teams, roles, and ceremonies. In Module Three, you learned about Scrum, Kanban, and other frameworks.
Now it is time to see Agile in real life. Agile is not just for software companies. It works for schools, families, small businesses, churches, sports teams, and even personal projects. Anything that has steps and needs feedback can be done with Agile.
In this module, we will learn how to use Agile at school, at home, and in business. We will also learn about common Agile mistakes, how to measure success, and how to keep improving. Finally, you will complete your certification project and present it.
By the end of this module, you will be a Certified Agile Expert, ready to bring Agile thinking to everything you do.
Let’s begin!
After finishing this module, you will be able to:
Emeka is 15 years old and lives in Port Harcourt. His family sells food at a big market every Saturday. Every week, the family struggled. Some items were missing. Others were too many. Customers complained about waiting too long.
Emeka remembered what he learned about Agile. He said, "Mummy, Daddy, let’s try Agile for our market day."
First, Emeka helped them create a backlog of everything needed for market day: buy rice, buy beans, buy oil, cook, pack, set up the stall, and so on.
Next, the family held a short sprint planning meeting each Thursday. They chose the most important items for that Saturday. They called this their "market sprint".
On market day, they used a Kanban board drawn on cardboard. Three columns: "To Do", "Doing", and "Done". As each task was finished, it moved across the board. Everyone could see what was happening.
After the market, the family held a retrospective. They asked:
The first week, they learned that they needed more spoons. The second week, they learned to prepare food faster. The third week, they learned to arrange the stall better.
After one month, the family was much more organised. Sales went up. Customers were happier. Emeka’s father said, "This Agile thing works!"
Moral of the story: Agile works everywhere – even at a market stall. Backlogs, sprints, Kanban boards, and retrospectives help any family or business improve.
Definition: Agile outside software means using Agile ideas for non-computer projects.
Why it is important: Agile works for any task that has steps and needs feedback.
Simple explanation: Like using a football strategy for a different game – the ideas still work.
Real-life example: Schools, hospitals, and shops use Agile ideas.
School example: Group projects use sprints and reviews.
Home example: Families use Kanban boards for chores.
Nigerian example: Market traders use backlogs and reviews.
Illustration:
Agile Everywhere: School Home Business Projects Chores Sales
Mini summary: Agile works outside software too. Schools, homes, and businesses can all use it.
Definition: Agile for school means using backlogs, sprints, and reviews for class projects.
Why it is important: School projects often need feedback and changes.
Simple explanation: Like a group project split into weekly sprints with teacher check-ins.
Real-life example: Students use Kanban boards for homework.
School example: A science project done in weekly sprints.
Home example: A study plan split into weekly goals.
Nigerian example: Nigerian students use backlogs for exam prep.
Illustration:
School Agile: Week 1 Sprint → Review → Week 2 Sprint → Review → Final
Step-by-step:
Mini summary: Agile makes school projects easier. Use sprints, reviews, and retrospectives.
Definition: Agile study plans split learning into short focused sprints.
Why it is important: Spaced study with feedback works better than cramming.
Simple explanation: Like studying one topic per week and testing yourself.
Real-life example: Students use sprints for exam prep.
School example: Weekly subject sprints.
Home example: Family reading plans in sprints.
Nigerian example: Students use sprints before WAEC or JAMB.
Illustration:
Study Sprint Example: Sprint 1: Maths basics Sprint 2: Maths practice Sprint 3: Review + test
Step-by-step:
Mini summary: Agile study plans use short, focused sprints with self-tests.
Definition: Agile for personal projects uses backlogs and reviews for things you want to achieve.
Why it is important: Big personal goals feel easier in small sprints.
Simple explanation: Like building a reading habit in weekly sprints.
Real-life example: Personal fitness or learning new skills.
School example: Learning to code with sprints.
Home example: Learning a new recipe each week.
Nigerian example: Learning to play the talking drum in weekly sprints.
Illustration:
Personal Sprint Example: Goal: Read 5 books this year Sprint 1: Book 1 Sprint 2: Book 2 Sprint 3: Book 3
Mini summary: Personal projects get easier with sprints and reviews.
Definition: Agile for families uses boards, sprints, and retrospectives for home tasks.
Why it is important: Families work better when tasks are clear and shared.
Simple explanation: Like a chore board with To Do, Doing, and Done.
Real-life example: Families use Kanban for chores.
School example: Families use sprints for homework routines.
Home example: Weekend sprint for cleaning the house.
Nigerian example: Family sprints for preparing for a big event.
Illustration:
Family Board: To Do: Sweep, Wash plates Doing: Cook dinner Done: Take out trash
Step-by-step:
Mini summary: Agile families use boards and reviews. Chores become easier and fairer.
Definition: Agile for small businesses means using sprints, boards, and reviews to serve customers better.
Why it is important: Small businesses need to change fast.
Simple explanation: Like trying a new product each month and checking sales.
Real-life example: Shops test new items in small batches.
School example: School shops try new snacks each term.
Home example: Family businesses try new markets.
Nigerian example: Nigerian market traders try new products in sprints.
Illustration:
Small Business Sprint: Sprint 1: Try new product Review: Did customers like it? Sprint 2: Adjust and try again
Mini summary: Small businesses use sprints to try and improve products.
Definition: Agile for community projects uses sprints and reviews for group goals.
Why it is important: Community projects involve many people and change often.
Simple explanation: Like planning a community clean-up in short sprints.
Real-life example: Churches and clubs plan events in sprints.
School example: Sports teams prepare in weekly sprints.
Home example: Neighbourhood meetings use backlogs.
Nigerian example: Nigerian youth groups use sprints for events.
Illustration:
Community Sprint: Week 1: Plan Week 2: Invite people Week 3: Do the project Week 4: Review and celebrate 🎉
Mini summary: Community projects run better with sprints and shared boards.
Definition: Mistakes happen. Knowing them helps you avoid them.
Why it is important: Agile can fail if used wrongly.
Simple explanation: Like using too many rules for a small project.
Real-life example: Teams doing ceremonies without improving.
School example: Groups that talk but do not work.
Home example: Families that plan but forget to act.
Nigerian example: Businesses that use Agile words but work the old way.
Table of common mistakes:
| Mistake | What Happens | How to Fix |
|---|---|---|
| No clear goal | Confusion | Set a sprint goal |
| Too many ceremonies | Wasted time | Keep meetings short |
| No review or retrospective | No improvement | Hold them every sprint |
| No estimation | Overloaded team | Estimate tasks |
| Ignoring feedback | Stuck with old ideas | Listen and change |
| Too big a team | Slow decisions | Keep 5–9 people |
Mini summary: Common mistakes: no goal, too many meetings, no reviews. Fix them early.
Definition: Agile metrics are numbers that show how well your team is doing.
Why it is important: What you measure, you can improve.
Simple explanation: Like a score in a game – it shows how well you are playing.
Real-life example: Banks track velocity and cycle time.
School example: Groups track how many tasks they finish weekly.
Home example: Families track chores completed.
Nigerian example: Traders track daily sales and deliveries.
Illustration:
Key Agile Metrics: - Velocity: work done per sprint - Cycle Time: time from start to finish - Throughput: items completed per week - Flow Efficiency: smoothness of work
Step-by-step:
Mini summary: Agile metrics measure how well the team is doing. Track them every sprint.
Definition: Cycle time is how long a task takes from when you start it to when you finish. Lead time is from when it was requested to when it is delivered.
Why it is important: Shorter times mean happier users.
Simple explanation: Like ordering food at a restaurant. Lead time is from order to eating. Cycle time is from cooking start to plate.
Real-life example: Banks track how long transactions take.
School example: Students track how long each subject takes.
Home example: Families track how long cooking takes.
Nigerian example: Traders track order-to-delivery time.
Illustration:
Lead Time: Order → Delivered Cycle Time: Started → Finished Shorter = Better 🎉
Mini summary: Cycle time and lead time show how fast the team delivers. Shorter is better.
Definition: Review is showing work. Retrospective is improving the team.
Why it is important: Both keep teams focused and learning.
Simple explanation: Like a class presentation and a class discussion after.
Real-life example: Banks hold reviews and retros every sprint.
School example: Groups show work, then discuss improvement.
Home example: Families show chores, then talk about what to change.
Nigerian example: Market traders show new products, then discuss.
Illustration:
Review: What did we show? Retro: What did we learn?
Step-by-step:
Mini summary: Review shows work to users. Retrospective improves the team.
Let’s build a real Agile plan for a Nigerian family.
Goal: Prepare for a family event in 4 weeks.
Backlog: Invite guests, plan menu, buy food, cook, decorate, arrange seats, welcome guests.
Sprints:
Kanban Board: To Do | Doing | Done
Review: After the event, ask guests what they liked.
Retrospective: Family discusses what to improve next time.
Illustration:
Week 1 → Week 2 → Week 3 → Week 4 (Invites) (Shopping)(Cooking) (Event)
Mini summary: Agile helps families plan big events in small sprints with reviews.
Definition: Nigerian businesses use Agile to grow faster and serve customers better.
Why it is important: Agile helps them change quickly with the market.
Simple explanation: Like a trader who tries small batches before buying in bulk.
Real-life example: Banks use Scrum for new features.
School example: Business clubs use sprints for events.
Home example: Home-based businesses use Kanban.
Nigerian example: Lagos fintechs use Scrum; Abuja restaurants use Kanban.
Illustration:
Nigerian Businesses Using Agile: Fintech → Scrum for features Retail → Kanban for orders Farms → Sprints for planting Schools → Sprints for events
Mini summary: Nigerian businesses use Agile to stay fast, flexible, and customer-focused.
Your certification project brings everything together.
Project idea: Plan and run a real Agile project in school, home, or a small business.
Steps:
Illustration:
Project Flow:
Choose project
|
V
Backlog
|
V
Framework (Scrum/Kanban)
|
V
Run sprints + reviews
|
V
Metrics
|
V
Report + Present 🎉
Mini summary: The certification project applies everything. Plan carefully and present well.
You have learned a lot. Let’s review.
Module One: Foundations – Agile values, principles, Waterfall vs Agile.
Module Two: Teams and ceremonies – roles, standups, reviews, retrospectives.
Module Three: Scrum and Kanban – backlogs, user stories, WIP limits, velocity.
Module Four: Real life – school, home, business, metrics, certification.
Illustration:
Your Skills: +----------------+ | Foundations | +----------------+ +----------------+ | Teams | +----------------+ +----------------+ | Scrum/Kanban | +----------------+ +----------------+ | Real Life | +----------------+ +----------------+ | Certification | +----------------+
Mini summary: You have mastered foundations, teams, frameworks, and real-life Agile.
Your certification is proof that you are an Agile Expert.
Next steps:
Illustration:
Certification
|
V
Portfolio
|
V
Share with others
|
V
Help others learn
|
V
Apply skills
|
V
Agile Expert 🎉
Mini summary: Your certification opens doors. Keep growing, sharing, and leading.
| Word | Simple Definition |
|---|---|
| Agile Everywhere | Using Agile outside software. |
| Personal Sprint | A short cycle for personal goals. |
| Family Board | A Kanban board for household tasks. |
| Business Sprint | A short cycle for a business goal. |
| Community Sprint | A short cycle for a community project. |
| Metrics | Numbers that show how well things are going. |
| Velocity | Work done per sprint. |
| Cycle Time | Time from starting to finishing a task. |
| Lead Time | Time from request to delivery. |
| Throughput | Items completed per week. |
| Review | Showing work to users. |
| Retrospective | Meeting to improve the team. |
| Feedback | Comments that help you improve. |
| Improvement | Getting better each cycle. |
| Certification | Proof of your skills. |
School Home Business Community Sprints Boards Sprints Sprints
Review: Show work → Get feedback Retro: Ask 3 questions → Pick 1 change
Lead Time: Order → Delivered Cycle Time: Started → Finished
Choose project
|
V
Backlog → Sprint → Review → Retrospect
|
V
Report → Present 🎉
Module 1: Foundations
|
V
Module 2: Teams & Ceremonies
|
V
Module 3: Scrum & Kanban
|
V
Module 4: Real Life & Certification
|
V
Agile Expert 🎉
| Feature | School | Home |
|---|---|---|
| Framework | Sprints | Kanban |
| Reviews | Teacher feedback | Family discussion |
| Goal | Grades and learning | Smooth routines |
| Feature | Cycle Time | Lead Time |
|---|---|---|
| Starts | When work begins | When requested |
| Ends | When finished | When delivered |
| Focus | Team speed | Customer experience |
| Feature | Velocity | Throughput |
|---|---|---|
| Measures | Points per sprint | Items per week |
| Used in | Scrum | Kanban |
| Purpose | Planning | Flow |
| Feature | Family Sprint | Business Sprint |
|---|---|---|
| Goal | Event or chore | Product or service |
| Review with | Family | Customers |
| Length | 1–2 weeks | 1–4 weeks |
Lesson 1: Agile works outside software too.
Lesson 2: Agile helps school projects with sprints and reviews.
Lesson 3: Study plans work better in short sprints.
Lesson 4: Personal projects get easier with sprints.
Lesson 5: Families use boards and reviews for chores.
Lesson 6: Small businesses use sprints to test ideas.
Lesson 7: Community projects run well with sprints.
Lesson 8: Common mistakes: no goal, too many meetings.
Lesson 9: Metrics show progress. Track them each sprint.
Lesson 10: Cycle time and lead time show speed.
Lesson 11: Reviews show work; retrospectives improve teams.
Lesson 12: Agile helps plan family events in sprints.
Lesson 13: Nigerian businesses use Agile daily.
Lesson 14: The certification project applies everything.
Lesson 15: Review of foundations, teams, frameworks, real life.
Lesson 16: Certification opens doors. Keep growing.
Congratulations! You have finished Module Four and the entire Agile Fundamentals course. You learned how Agile works outside software. You learned how to use Agile at school, at home, and in small businesses and community projects. You learned about common mistakes and best practices. You learned about Agile metrics like velocity, cycle time, and lead time. You learned to hold reviews and retrospectives. You prepared and completed your certification project. Most importantly, you are now a Certified Agile Expert. Keep using Agile, keep sharing it, and keep learning!
Match the term to its meaning.
| Term | Meaning |
|---|---|
| 1. Cycle Time | A. Time from request to delivery |
| 2. Lead Time | B. Work done per sprint |
| 3. Velocity | C. Time from start to finish |
| 4. Review | D. A meeting to improve the team |
| 5. Retrospective | E. Showing work to users |
Answers: 1-C, 2-A, 3-B, 4-E, 5-D
Title: “Run a Real Agile Project Together”
Instructions: In groups of 3–4, choose a real small project (like planning a class event or a study sprint). Write a backlog. Choose Scrum or Kanban. Run the project for 1–2 weeks. Hold standups, a review, and a retrospective. Track one metric. Present results to the class.
Goal: Experience Agile in a real project.
Task: Choose a personal goal for the next two weeks. Then:
Hint: Keep it small and realistic.
Project: “My Real-Life Agile Plan”
Create a complete Agile plan for a school, home, or community project. Include:
Example:
Project: Family market day Backlog: buy rice, buy beans, cook, pack, stall setup, sell, cleanup. Framework: Kanban Sprints: Weekly Thursday planning. User Stories: "As a customer, I want quick service." Review: After market. Retro: Sunday evening. Metric: Items sold. Celebrate: Family outing 🎉
Assignment: Complete your certification project. Choose a real project in school, home, or a small business. Then:
Submit: Your plan, board/backlog, metric data, report, and presentation slides.
Congratulations! You have completed the entire Agile Fundamentals course. Here are some next steps you can take:
Remember, this is just the beginning. You are now a Certified Agile Expert. Keep using Agile, keep teaching it, and keep improving!
End of Module Four – Agile Fundamentals
🎉 Congratulations! You have completed the entire Agile Fundamentals course! 🎉