Full-day interactive training | Trainer scripts included | Hands-on lab walkthrough
"Welcome everyone. Today we're exploring Scrum—a framework for building products in short cycles. You're fresh from college, skilled in Python and AI. Scrum isn't magic; it's structure that lets teams move fast without chaos.
Here's the reality: your Apachita agent project has multiple moving pieces—Sourcing, Logistics, Quality agents. Without process, you'd step on each other's code, miss deadlines, and burn out. Scrum fixes that with three simple pieces: roles, ceremonies, and artifacts."
"Scrum has three roles. Think of them as hats. Each person wears one hat—they can't wear two at once because it creates conflicts of interest."
Product Owner: "They own the 'what' and 'why.' Their job is to know the business. They decide: Should we build vendor priority sorting or SHG feedback collection first? They live with stakeholders, understand the market."
Scrum Master: "They own the 'how'—process, not technical decisions. They're like a coach. If you're blocked on WhatsApp API credentials, they chase the issue. If someone's exhausted from 12-hour sprints, they protect the team."
Dev Team: "That's you. Self-organizing. You decide 'we'll pair on the LangGraph refactor.' You estimate complexity. You commit to delivery."
"Scrum is all about rhythm. There are four ceremonies—think of them as checkpoints. Each has a purpose and a time limit."
Sprint Planning: "Start of sprint. 'What are we building this sprint?' PO talks about priorities, team estimates, we agree on a goal."
Daily Standup: "15 mins, every morning. Not a status report. You answer: What did I do? What's next? Any blockers? If blocked, we fix it after standup."
Sprint Review: "Demo day. We show stakeholders what we built. They give feedback. We update the backlog based on feedback."
Retrospective: "Team only. No stakeholders. What went well? What was hard? What will we do differently next sprint?"
When: Start of sprint.
Duration: 2–4 hours.
Team + PO discuss backlog items. Team forecasts story points and commits to a sprint goal.
When: Every morning.
Duration: 15 mins.
Each dev answers: What did I do? What am I doing? Any blockers? Not a status report—a sync.
When: End of sprint.
Duration: 1–2 hours.
Team demos finished work to stakeholders. Gather feedback. Update the backlog.
When: After review.
Duration: 1–1.5 hours.
Team reflects: What went well? What didn't? What will we improve next sprint?
"Artifacts are the 'stuff' of Scrum. Three main ones: the Product Backlog, Sprint Backlog, and the Increment (what you deliver)."
Product Backlog: "Master list. Every feature, bug, improvement—ranked by business value. Owned by the PO. Never 'done'—always growing."
Sprint Backlog: "A slice of the Product Backlog. 'This sprint, we're tackling these items.' Once sprint starts, don't add. Protect your commitment."
Increment: "The working stuff. At the end of each sprint, you have a complete, tested, deployable slice. Not a prototype—something you can run in production."
"Azure DevOps is your Scrum digital home. It's built by Microsoft and it understands Scrum natively. Think of it as GitHub + Jira + CI/CD in one place."
"You get: a backlog to track stories, a board to visualize your sprint, Git repos for code, and pipelines to automate testing and deployment. All connected."
"Azure DevOps organizes work as 'Work Items.' You'll see Epic, Feature, User Story, Task, and Bug."
User Story: "This is the smallest, most important unit. 'As a vendor, I want to reply to the agent via WhatsApp so I can sell my waste directly.' Clear, testable, valuable."
Story Points: "We estimate complexity, not time. Use Fibonacci: 1, 2, 3, 5, 8, 13. A 1-pointer? 'Add logging.' An 8-pointer? 'Refactor WhatsApp listener with ReAct.' A 13-pointer? That's probably too big—split it."
"The Sprint Board is your daily command center. You see columns: To Do, In Progress, In Review, Done."
"At the start of a sprint, all your committed items are in 'To Do.' During the day, you move cards across columns as you work. By day 5, everything should be in 'Done.'"
"The burndown chart shows your progress. If it's flat—not moving—that signals blockers. Raise them in standup."
"Let's walk through a real example: your Apachita project. You have a PO, fresh-grad engineers, a complex agent architecture. How do you ship fast without chaos?"
"Scrum + Azure DevOps is the answer. You break the Apachita roadmap into 2-week sprints. Each sprint, you commit to building a slice of an agent."
"Sprint 1: 'Sourcing agent MVP.' Sprint 2: 'Add validation.' Sprint 3: 'Quality checks.' By Sprint 6, you have a full system. And you shipped working pieces on day 10, not on day 60."
"Why does this matter? Stakeholders see progress early. You get feedback. The team stays motivated. You can pivot if the market changes."
"Here's your rhythm for a 2-week sprint."
"Day 1, 9 AM: Sprint Planning. You commit to 20 story points. Day 2–5: You code. Every morning, 10 AM standup. Every PR triggers Azure Pipelines—tests run, Docker builds, staging deployment. Day 5 PM: Demo to stakeholders. Then retro."
"Repeat. Every sprint, you ship something real. Every sprint, you learn."
"Now we're getting hands-on. I'm going to walk you through creating your Azure DevOps project from scratch. You'll follow along on your laptops. By the end, you'll have a live backlog and sprint board for your AI agent team."
"We'll cover: creating a project, setting up your first user story, creating a sprint, and assigning work to team members. Then you'll practice on your own."
Open dev.azure.com in your browser. Sign in with your Microsoft account (or create one if needed).
Click "Create new organization." Name it something like apachita-agents or myteam-devops.
Note: You only do this once per team. If your org already exists, skip to "Create project."
Click "+ New project." Name it Apachita-Sprint-1 (or your agent project name).
Visibility: Choose "Private" (only team members can see).
Version control: Choose "Git".
Work item process: Choose "Scrum".
Azure DevOps creates the project (takes ~30 seconds). You'll see a welcome page with tabs: Boards, Repos, Pipelines, etc.
Click the Backlog tab on the left sidebar. You'll see an empty backlog with no items yet.
Click "+ New Work Item" → select "Epic." Name it "Sourcing Agent MVP".
Click "Save." The Epic appears at the top of your backlog.
Click "+ New Work Item" → select "User Story." Name it:
Click "Save." The story appears in your backlog.
Click on the story you just created. In the right panel, look for "Effort" or "Story Points." Set it to 8.
Click "Save."
Repeat steps 7–8 for these stories:
Your backlog now shows: Epic → 3 stories (8+13+5=26 pts).
Click the Sprints tab (or "Boards" → "Sprints" if it's nested). You'll see a sprint planning view.
Click "+ New sprint." Name it "Sprint 1 - Sourcing MVP".
Sprint duration: 2 weeks (10 working days).
Click "Create."
Go back to Backlog. You'll see your stories on the left, Sprint 1 on the right.
Drag your 3 stories into Sprint 1. (Total: 26 points.)
Click the sprint name. You'll see a Kanban board with columns: To Do, In Progress, Review, Done.
All 3 stories start in "To Do."
Click on the first story ("WhatsApp listener"). In the right panel, click "Assigned to" and select a team member (or yourself for testing).
Assign Story 1 to Engineer A, Story 2 to Engineer B, Story 3 to Engineer A.
Drag Story 1 from "To Do" to "In Progress." (Engineer A started working on WhatsApp listener.)
Drag Story 2 to "In Progress." (Engineer B started the LangGraph state machine.)
Drag Story 1 to "In Review." (Engineer A finished WhatsApp listener, waiting for code review.)
Notice the board: 1 in review, 1 in progress, 1 in to-do.
Drag Story 1 to "Done." (Code review approved.)
Drag Story 2 to "Done." (LangGraph state machine completed.)
Move Story 3 to "In Progress" (last-minute push).
Result: 2 stories done (8+13=21 pts), 1 in progress (5 pts). Velocity this sprint: 21 pts (close to your 20-pt average).
Sprint Review (4 PM, Day 5): Engineer A demos the WhatsApp listener. Stakeholders ask: "What if a vendor doesn't respond for an hour?" You add a task: "Implement message timeout." Added to next sprint's backlog.
Retro (5 PM): Team discusses:
Outcome: You move Story 3 back to the backlog (unfinished = normal). You have 2 shipped features + real feedback + a process improvement. You've shipped working software in 10 days.
"Now we link code to stories. When you commit code with a story ID in the message, Azure DevOps auto-links it. When your PR merges, the story moves to Done."
Click the Repos tab. Click "+ New repository." Name it apachita-agents.
Copy the HTTPS URL (for cloning).
(Replace "US-1" with your actual story ID, visible in Azure DevOps.)
Key: The commit message includes "Fixes US-1" (or "Closes US-1"). Azure DevOps detects this and links the commit to your story.
In Azure Repos, click "Create a pull request." Select your feature branch.
Title: "Feat: WhatsApp listener with Twilio - Closes US-1"
Click "Create." The PR links to story US-1 automatically.
Tip: Add a code reviewer from your team. They review & approve. Then merge.
Go back to your Sprint Board. When you merge the PR, the story automatically moves to "Done."
Magic: No manual updates. Work item + code + CI/CD = fully connected.
Next step: Repeat this setup for your real Apachita project. Invite your team. Start Sprint 1 on [date]. Run daily standups. Demo on day 10. Retro. Repeat.