https://nkdagility.com/capabilities/training-courses/scrum-training-courses/applying-professional-scrum-for-software-development-aps-sd-with-certification/ copied to clipboard!

Applying Professional Scrum for Software Development (APS-SD) with Certification

Experience APS-SD: Hands-on Scrum training for delivering quality software. Gain practical skills in Agile, DevOps, and Scrum principles. Free PSD I certification exam included. Enhance your software development expertise.

APS-SD |Scrum.org |Intermediate

GOAL: 6 participants

0 Participants

Rolling delivery

Preordering grants you extra coaching, future discounts, and input on scheduling and format.

Preorder Follow Private / Corporate learn more

About Our Funding Model

Our funding model supports busy professionals by ensuring courses are fully funded and guaranteed.

Funding Mode

We proceed with courses only when the participant goal is met, ensuring value and support for everyone involved. Funds are only taken once the target is met.

Collaboration Benefits

Pre-ordering gives exclusive access to help shape the course’s start date, schedule, and format.

Get more information

What Applying Professional Scrum for Software Development Students Say

Course Overview

The Applying Professional Scrum for Software Development (APS-SD) course is designed for various roles within a Scrum Team, including architects, analysts, programmers, database developers, testers, managers, IT-Operations, Scrum Masters, and Product Owners. It is recommended that the entire Scrum Team, consisting of Developers, Scrum Master, and Product Owner, attend the course together to experience the benefits of teamwork fully. Attending as a team allows for immediate application of learned concepts and the ability to draw upon classroom experiences during challenging situations. However, individuals attending without their entire team can still derive significant value from the course. They will have the opportunity to work within a Scrum Team during the training and can transfer their learnings to their teammates. This often leads to convincing their colleagues of the advantages of utilizing Scrum, Agile, and DevOps practices.

Course Outcomes

The Agile Mindset: Fostering Professionalism and Understanding the Scrum Framework
Collaboration and Empowerment: Effective Teamwork within a Scrum Team
Delivering Value: Defining and Achieving the Definition of Done
Efficient Backlog Management: Practices for Feature Slicing and Prioritization
Code Excellence: Ensuring Quality and Managing Technical Debt
Architecting for Agility: Agile Principles for Building Adaptive Systems
Test-Driven Development: Driving Quality through Test-First Practices
Amplifying Skills: Maximizing Collaboration through Pair Programming
Quality Assurance in Agile: Agile Testing and Other Quality Practices
Synergizing Development and Operations: Integrating DevOps with Scrum

Course Objectives

Foster Real Collaboration: Experience the power of collaboration between Developers, Product Owner, and Scrum Master to create and deliver a high-quality and valuable product.
Embrace Agile Engineering Practices: Apply modern Agile engineering practices to build and deliver working software. Explore techniques that enhance productivity, efficiency, and quality.
Leverage DevOps Tools: Utilize supportive DevOps tools to streamline development and delivery processes. Learn how to integrate and automate workflows for faster and more reliable software delivery.
Comprehend the Synergy: Understand the interplay between different elements of Scrum and complementary practices. Gain insights into how they work together to enable agility and maximize outcomes.

Why Learn With NKD Agility?

We are 4.8-star rated on Trustpilot!
We have helped 2,600+ people learn Scrum since 2010.
We are not trainers, we are consultants that are still in the trenches.
All participants get self-paced learning support.
Receive regular chances to attend another course at no cost.

Syllabus

Our comprehensive syllabus is designed to accommodate various learning styles, whether you prefer a traditional in-depth session, a flexible immersive experience, or a structured mentor program. Each session can be delivered in the following formats:

Traditional Learning Experience: Engage in full-day or half-day sessions led by expert trainers in an interactive classroom setting. Perfect for those seeking an intensive, focused learning experience.
Immersive Learning Experience: Enjoy a multi-week program that breaks down full-day sessions into shorter, more manageable classes, integrating real-world applications and reflections for continuous improvement. Assignments are only available as part of this format, encouraging participants to apply their learning practically.
Mentor Programs with Immersive Experiences: Participate in a series of immersive learning sessions as part of our mentor programs, combining structured learning with personalized guidance and continuous feedback over time. For more information, visit our Mentor Programs page.

Our immersive programs empower growth through incremental learning, outcome-based assignments, and facilitated reflections, ensuring that the skills you gain are practical, applicable, and ready to be used in your work environment. Facilitated Reflections are a cornerstone of our immersive approach, allowing participants to engage deeply with the material. In each session, you will have the opportunity to reflect on your learning, discuss challenges and successes with peers, and gain actionable feedback from professional trainers. These reflective sessions enhance understanding, foster continuous improvement, and support your growth in a collaborative environment.

Course Kickoff and Scrum Foundations

Session 1 120+

Course Overview & Team Formation – Kicking off the course, students are introduced to the immersive training format and form Scrum Teams. The .NET Battleship case study is presented, and participants ensure their development environment is set up. Through initial discussions and a quick team exercise, they explore the Agile mindset and Scrum basics (roles, events, artifacts, and values). This session lays the foundation for teamwork, emphasizes the importance of collaboration and getting to “Done,” and prepares students for the hands-on sprints to follow.

Ask Facilitate a discussion within your organization about your current product development process and capture how work is done today. Focus on how ideas move from concept to release, and who is involved at each step.

Agile Principles and Scrum Framework Fundamentals

Session 2 120+

Scrum Theory & Values – Students delve into the core principles of Agile and the fundamentals of Scrum. The class reviews the Agile values and principles from the Manifesto and discusses why empirical process control is crucial for complex software development. Each element of the Scrum framework (the roles, events, artifacts, and the commitments) is introduced, emphasizing how they interrelate and the purpose they serve. By examining the Scrum values (Commitment, Courage, Focus, Openness, Respect), participants learn how these create an environment for trust and self-organization. This foundational session prepares students to identify how Scrum could address issues in their own projects and sets the stage for deeper exploration in subsequent sprints.

Ask Consider how Agile principles and the Scrum framework could improve your team’s way of working. Identify at least one change inspired by Scrum or Agile values that you will introduce to your current process, and plan an experiment to implement it.

Product Backlog Management and Slicing User Stories

Session 3 120+

Backlog Refinement & Slicing Techniques – In this session, students focus on efficient Product Backlog management. They learn how a well-groomed backlog supports transparency and adaptability. The class practices story slicing – breaking down large features or requirements into thinner vertical slices that can be completed within one Sprint. Techniques for prioritization and ordering of the backlog are discussed, including the DEEP criteria (Detailed appropriately, Estimated, Emergent, Prioritized) for a healthy backlog. Participants also explore methods like relative estimation (Story Points) and the importance of clear acceptance criteria. By the end, students can describe how to refine a backlog item to be “Sprint Ready” and have strategies to improve backlog refinement in their own teams.

Ask Evaluate your team’s current backlog refinement or grooming practices and implement one improvement to enhance how work is made ready for development. This could involve applying a new story-splitting technique, refining acceptance criteria, or re-prioritizing the backlog based on value. Observe and share the impact on the next Sprint’s planning or outcomes.

Sprint 1 Simulation – Delivering a 'Done' Increment

Session 4 120+

Hands-on Sprint & Self-Organization – Students participate in Sprint 1 using the Battleship case study, experiencing the Scrum events and the pressure of delivering a potentially shippable increment. They conduct Sprint Planning to select a modest product goal (e.g. implement a basic game feature) and then collaborate to build and test it within the timebox. During this Sprint, teams encounter real-world issues like unclear requirements, integration challenges, and the need to self-organize under time constraints. After a brief Sprint Review (sharing the increment, such as a working game component) and a time-boxed Retrospective, the instructor leads a debrief. The discussion centers on what it means to get to “Done” and how boundaries and agreements (like a Definition of Done, coding standards, and clear roles) enable effective self-management. This sets the stage for introducing improvements in subsequent sprints.

Ask Reflect on how your team currently self-manages and what minimal rules or agreements might improve its ability to organize work. Identify one change in team working agreements or boundaries (aligned with Scrum’s framework) that you will implement to help the team self-organize more effectively, and monitor its impact.

If your team lacks a clear Definition of Done, convene the team to draft one (including criteria like code review, all tests passing, deployed to a test environment, etc.). Use this Definition of Done in your next Sprint and observe if the team collaborates more to meet it.
Evaluate the clarity of roles and responsibilities on your team. If developers are unsure who should merge code or who speaks to stakeholders, establish a simple RACI matrix or checklist for these activities. Share it with the team so everyone knows the boundaries of each accountability (e.g. “Developers own code quality and merging; the Product Owner approves scope changes,” etc.).
During your next Daily Scrum, pay attention to whether team members are coordinating or just reporting status. Introduce a reminder that the Daily Scrum is for planning together. For one Sprint, encourage the team to explicitly identify any task-swapping or collaboration needed each day (e.g. two developers swarming on a tough problem) and note if this increases progress toward the Sprint Goal.
Implement a lightweight team agreement for interruptions: for example, decide as a team that during Sprint execution, any new urgent work must be brought to the Scrum Master/Product Owner first (instead of individuals agreeing to extra work ad hoc). See if this boundary protects focus and brings more visibility to mid-Sprint changes.
If your team doesn’t hold Retrospectives regularly, schedule a short, focused Sprint Retrospective at the end of the current sprint. Establish the norm that the team will pick one process improvement from each Retro to carry into the next Sprint. Notice if having this cadence makes the team more proactive in addressing issues (an indicator of growing self-management).
Have a conversation with your Scrum Master or a team lead about how decisions are made on your team. If decisions often wait for manager approval, propose that the team tries a Sprint where it makes more decisions autonomously (within certain boundaries), such as redesigning a component or reordering tasks, and then reviews the outcomes. This tests and potentially expands the team’s self-management capability.
Focus on Sprint Goals: Ensure that for your next Sprint, the team crafts a clear Sprint Goal in Sprint Planning. Throughout the Sprint, encourage team members to self-organize their work each day around achieving that goal (rather than just individual tasks). Observe at the Sprint’s end if having a shared goal improved collaboration and outcome.

Ensuring Quality – Definition of Done and Technical Excellence

Session 5 120+

Quality and Done Criteria – This session highlights the importance of building quality in and managing technical debt. The class discusses the Definition of Done (DoD) and how it acts as a quality gate for each increment. Students examine examples of DoD criteria (code review completed, all unit tests passed, integrated in main branch, deployed to test environment, etc.) and compare them with their team’s current practices. The concept of technical debt is introduced with examples of how unchecked debt can slow teams down. Students learn modern engineering practices to maintain quality, such as continuous integration, automated testing, and refactoring techniques to pay down technical debt. By the end, they understand how a strong Definition of Done and a culture of technical excellence help Scrum Teams deliver “Done” increments consistently and sustainably.

Ask Review your team’s current Definition of Done (or lack thereof) and implement at least one improvement that raises the quality bar for your product increments. This could mean establishing a new Done criterion (e.g. all critical bugs fixed, or performance test passed) or reinforcing an existing one that is often overlooked.

Agile Engineering Practices – Test-Driven Development (TDD)

Session 6 120+

Test-Driven Development & Unit Testing – Students are introduced to Test-Driven Development (TDD), a core Agile engineering practice for ensuring quality and guiding design. The instructor demonstrates the Red-Green-Refactor cycle using .NET (for example, writing a failing unit test for a Battleship game function, writing minimal code to pass the test, then refactoring the code). Participants see how writing tests first can lead to simpler, more maintainable code and a robust suite of regression tests. The class also discusses unit testing frameworks (like NUnit/xUnit for .NET) and the idea of testing pyramid (unit vs integration vs end-to-end tests). Students practice writing a test case themselves in a provided code sandbox. By experiencing TDD in action, they gain confidence in applying it to their work and understand how it helps catch defects early, supports refactoring, and drives better design.

Ask Apply test-driven development on a small scale in your own work. Choose a simple bug fix or new functionality and write a unit test for it before writing the code. Follow the Red-Green-Refactor cycle and observe how it influences your solution. Be prepared to share what you learned with your team.

Sprint 2 Simulation – Applying TDD and Continuous Integration

Session 7 120+

Hands-on Sprint with Engineering Focus – In Sprint 2 of the case study, teams build on the lessons of TDD and start integrating code frequently. During Sprint Planning, they select the next set of game features and explicitly plan how to incorporate test-first development and frequent integrations into their workflow. Throughout the Sprint, teams are encouraged to write unit tests for new functionality (for example, a test to ensure ships cannot overlap on the game board), run tests often, and integrate their code changes continuously using a source control workflow (like committing to the main branch or using pull requests). They encounter real issues like merge conflicts or failing tests, which reinforce the need for CI practices. By the Sprint Review, teams deliver a more advanced increment of the game. In the Retrospective, the discussion centers on the impact of TDD and CI – teams typically notice improved confidence in changes and faster feedback on defects. This exercise reinforces how Agile engineering practices and Scrum complement each other to help teams sustain quality while delivering quickly.

Ask Choose a small section of your codebase that you suspect is poorly structured or “smelly,” and perform a refactoring on it. The goal is to improve its readability or maintainability without changing its external behavior. Use tests (existing or newly written) to ensure you haven’t broken anything. Document what you changed and why for your team.

Find a long method or God class in your project that people avoid touching. Break it up – for example, extract one or two smaller methods or classes from it that have clear responsibilities. Run your test suite (or do manual testing if needed) to confirm the application still works exactly as before. Share the before-and-after code with a teammate and note if it’s easier to understand.
Identify duplicate or very similar code in two places (duplication is a common code smell). Refactor by creating a single utility or common function that both pieces of code call, removing the duplication. Ensure all tests pass (or the application still behaves correctly). In your next team meeting, mention this refactoring so others know about the new common function.
Choose a confusingly named variable, method, or class – something that tripped you or others up in the past. Use Rename Refactoring (a feature of most IDEs) to give it a clearer name that reflects its purpose. This is a simple change, but improves communication. Verify the project builds and works after the rename. This exercise can encourage the habit of continuously cleaning up naming.
If your project lacks tests, perform a manual refactoring with extra caution: first, manually test the relevant feature or module thoroughly before making changes. Then do a small improvement (such as extracting a constant from magic numbers, or splitting a complex conditional into simpler pieces) and manually test again. Although not ideal, this demonstrates the value of having tests for confident refactoring.
Partner with a colleague to review and refactor a piece of code together. One person can suggest improvements while the other makes the changes. This is a learning exercise for both: the reviewer practices spotting code smells, and the coder practices small refactoring steps. Share the final result with your team.
Pick a code area where you’ve recently found bugs, and refactor it to be more robust (for example, add null checks, input validation, or better error handling). Re-test the scenarios where bugs occurred. This type of defensive refactoring not only improves structure but also prevents future issues.
Look for an opportunity to simplify complex logic (nested if-else statements, complex boolean expressions, etc.). Refactor it to be more readable, perhaps using early returns, guard clauses, or boolean methods with clear names. Test that the logic still works correctly. Clean, simple code is easier to debug and extend.

Continuous Integration and Version Control Practices

Session 8 120+

CI/CD Fundamentals & Source Control – Students explore continuous integration practices that support frequent delivery of working software. The session covers version control best practices (branching strategies, commit messages, pull requests) and how they enable team collaboration while maintaining code quality. Participants learn about automated build pipelines and how they provide fast feedback on code changes. The class discusses different CI/CD tools and approaches (Azure DevOps, GitHub Actions, etc.) and examines how frequent integration reduces integration pain and supports sustainable delivery. Students also explore feature toggles and branching strategies that allow teams to integrate code daily without exposing incomplete features to users. By the end, they understand how CI/CD practices complement Scrum’s emphasis on potentially shippable increments and frequent feedback.

Ask Evaluate your team’s current code integration and version control practices and implement one improvement that reduces integration friction or increases deployment confidence. This might involve setting up automated builds, improving branching strategy, or establishing better commit practices.

Agile Testing and Quality Assurance Practices

Session 9 120+

Testing in Agile Teams – This session explores how testing practices need to evolve in Agile environments where requirements emerge and software is delivered frequently. Students learn about the testing pyramid (unit, integration, UI tests) and how different types of tests serve different purposes. The class discusses shift-left testing – moving testing activities earlier in the development cycle – and how testers and developers can collaborate more effectively. Participants explore test automation strategies, acceptance criteria as living documentation, and how to balance manual and automated testing. The session also covers exploratory testing and its role in discovering edge cases and usability issues. Students understand how quality is everyone’s responsibility in a Scrum Team and learn practical approaches to embed quality practices throughout the development lifecycle.

Ask Evaluate your team’s current testing approach and implement one improvement that increases confidence in software quality or reduces the time to find defects. This could involve shifting testing earlier, improving test automation, or enhancing collaboration between developers and testers.

DevOps Integration and Deployment Practices

Session 10 120+

DevOps & Deployment Strategies – Students explore how DevOps practices enable Scrum Teams to deliver working software more reliably and frequently. The session covers deployment automation, infrastructure as code, and monitoring practices that support continuous delivery. Participants learn about different deployment strategies (blue-green, canary, feature flags) and how they reduce deployment risk while enabling faster feedback. The class discusses observability practices – logging, monitoring, and alerting – and how they help teams understand system behavior in production. Students also explore how cross-functional collaboration between development and operations teams enables faster problem resolution and more reliable systems. By the end, they understand how DevOps practices complement Scrum’s goals of frequent delivery and empirical process control.

Ask Choose one DevOps practice that would benefit your team’s ability to deploy and monitor software more effectively. Implement a simple version of this practice and observe its impact on deployment confidence, feedback loops, or incident response.

Sprint 3 Simulation – End-to-End Integration and Delivery

Session 11 120+

Complete Feature Delivery – In the final sprint simulation, teams focus on delivering a complete, integrated feature of the Battleship game. They apply all the practices learned in previous sessions: TDD, continuous integration, automated testing, and DevOps practices. During Sprint Planning, teams select ambitious goals that require good collaboration and technical practices to achieve. Throughout the Sprint, they encounter realistic challenges like performance issues, integration problems, or changing requirements. Teams must self-organize to overcome these obstacles while maintaining quality and meeting their Sprint Goal. The Sprint Review showcases not just the working software but also the engineering practices that enabled its delivery. In the final Retrospective, teams reflect on their journey and identify which practices made the biggest difference in their effectiveness. This capstone experience demonstrates how Scrum and modern engineering practices work together to enable sustainable, high-quality software delivery.

Ask Reflect on the technical practices you’ve experimented with during this course and identify which ones provided the most value for your team. Create a plan to systematically adopt or improve these practices in your regular work, and share your insights with colleagues.

Scaling Agile Engineering Practices and Continuous Improvement

Session 12 120+

Organizational Agility & Scaling – The final session explores how the practices learned in the course can be scaled across larger organizations and multiple teams. Students discuss communities of practice, knowledge sharing, and how to spread technical excellence beyond individual teams. The class covers challenges and solutions for coordinating multiple Scrum Teams working on the same product, including shared Definition of Done, cross-team integration practices, and architectural considerations. Participants learn about continuous improvement culture and how to measure and track the effectiveness of engineering practices over time. The session also addresses how to overcome common organizational impediments to adopting Agile engineering practices. Students leave with actionable strategies for leading technical transformation in their organizations and becoming advocates for sustainable, high-quality software development practices.

Ask Design a strategy for promoting technical excellence and Agile engineering practices in your broader organization. Consider how to gain support, overcome resistance, and measure progress. Start implementing one element of your strategy and track its effectiveness.

Catchup & After

Two weeks after completion, participants are invited to join a follow-up catch-up session designed to address any remaining questions, ideas, or challenges that have emerged since the training. This session provides an opportunity to reflect on your experiences applying the concepts learned in the course, share insights, and receive additional support.

* Assignments are part of our Immersive Training Programs, encouraging participants to apply their learning practically between sessions for a more hands-on experience.

If we don't have dates that suit you, please sign up to be the first to know, or contact us for discounts or private training.

For those looking for a more guided, continuous learning journey, explore our Mentor Programs, where you can engage in a series of immersive learning sessions combined with ongoing mentorship.

Connect with Martin Hinshelwood

If you've made it this far, it's worth connecting with our principal consultant and coach, Martin Hinshelwood, for a 30-minute 'ask me anything' call.

Our Happy Clients

We partner with businesses across diverse industries, including finance, insurance, healthcare, pharmaceuticals, technology, engineering, transportation, hospitality, entertainment, legal, government, and military sectors.

Emerson Process Management

New Signature

SuperControl

Jack Links

Freadom

Boxit Document Solutions

Higher Education Statistics Agency

Sage

Ericson

Microsoft

Slaughter and May

YearUp.org

Graham & Brown

Epic Games

Workday

NIT A/S

Big Data for Humans

Hubtel Ghana

Department of Work and Pensions (UK)

Ghana Police Service

Washington Department of Transport

Nottingham County Council

Royal Air Force

New Hampshire Supreme Court

ProgramUtvikling

Genus Breeding Ltd

Deliotte

Boxit Document Solutions

Slaughter and May

Big Data for Humans