Technical Agility

Agility is not just about process. You must also attend to code quality.
Use a proven path for roll-out of technical skills in your organization.


Software development is a complex endeavor. While Lean and Agile methods are quite useful, it is critical not to forget the technical side of the equation: Behavior-Driven Development/Analysis; Test-Driven Development; Design Patterns; Emergent Design, and Advanced Software Development. Integrating business, management, process and technical practices is critical for any Lean and/or Agile endeavor to be effective.


We provide requirements and technical training for developers in a way that works in an holistic fashion with other Lean-Agile efforts.Our trainers have written award winning books and have deepened the understanding of design patterns, Test-Driven Development (creating what we call Sustainable TDD), emergent design and Agile architecture. We recognize the value of processes of Lean-Agile software development at the team level to increase the predictability and throughput of their development teams. Vital as this is, the code quality and changeability of designs gained from learning Design Patterns and TDD are just as critical for creating better software faster.

Read about the Software Development Skills Road-map.


Suggested order of courses

Each course in the technical agility curriculum can be tailored to take advantage of knowledge our clients already have or to take account of unusual circumstances in which normal approaches may not be effective.

At Net Objectives, we are passionate about helping teams create better software faster at a reasonable cost. We offer a complete curriculum of Technical Agile training that compliments your Agile transition needs. Here is the suggested order of courses for technical agility.

  1. Starting with alignment

    1. Effective Agile Requirements: ATDD with Behavior-Driven Development

  2. Laying a foundation of design and quality

    1. Design Patterns Thinking

    2. Foundations of Sustainable Design (online)

    3. Emergent Design Bundle

  3. Building quality into process

    1. Sustainable Test-Driven Development

  4. Amplifying gains with advanced software design

    1. Advanced Software Design


This two-day course that continues the exploration of design patterns begun in the Design Patterns Thinking course. This course presents detailed case studies and additional patterns.


Course Objectives: 

This course continues the exploration of design patterns thinking by exploring additional patterns and case studies. This course discusses patterns as forces, enabling them to be used even when the classic context for the pattern does not exist. It also continues with the principles of Commonality and Variability Analysis.

Learning Objectives: 

In this course, you will:

  • Learn seven patterns

  • Review and discuss case studies involving design patterns

  • Deepen your understanding of Commonality and Variability Analysis

Advanced Software Design

Design patterns enable the emergent design that is needed on Agile projects. Although patterns at one time were thought of as a “design up-front" technique, they can be used in Agile projects to encapsulate variations that are discovered over time.  For development organizations to thrive in an Agile environment, it is critical that the systems they create are not vulnerable to changing requirements, business priorities, technologies, or market pressures.


This course addresses key questions in modern development such as how to design systems that have changeability as a fundamental quality and how the team can communicate effectively when a design is in a constant state of change.


All Net Objectives consultants have hands-on practical experience with applying Lean thinking to the delivery of software technology solutions. Our approach is to show how Lean applies to an incremental realization of software features and systems and how to apply practices that improve the team’s ability to deliver.


How the course is organized

This course uses patterns in a new way. Historically, patterns have been thought of as part of an  “up-front design” style of development. Now, we realize they are powerful tools in an Agile environment, where much is assumed to be unknown at the beginning of a project, and where the design is expected to emerge through the iterative process.

Patterns are examples of following the wisdom that guides good design. They emphasize the importance of creating encapsulation and using delegation to segregate systems to protect them from cascading change. When they were first suggested, computers were fundamentally slower, and technology resources (memory, disk space) were far more expensive than they are today. The style of design suggested by patterns is far more realistic. Patterns are far more useful as collection of best practices rather than simply “reusable solutions.”


Participants learn to use patterns as part of a thought process that guides analysis, using “pattern orientation” as a way to understand an ever-changing problem domain.


Participants also learn to consider patterns in the context of testability (specifically unit testing), commonality-variability analysis, and a technique called “refactoring to the open-closed.” By combining these techniques into an overall paradigm of design, developers and teams learn to move a design forward confidently even when there is an expectation that the sand beneath their feet will shift.


Learning Objectives: 

In this course, you will learn:

  • How to use patterns thinking to enable your designs to emerge

  • How to add functionality to designs while minimizing complexity

  • What design patterns really are

  • Twelve specific design patterns

  • What code qualities you need to maintain to keep code flexible

  • How to use design patterns to keep code quality high

  • Several easy, low-cost practices that will improve the quality of your designs and code

  • How to use design patterns in an Agile environment

Design Patterns Thinking

This workshop equips the software triad (customer/Business stakeholder, developer, and tester) turn requirements into software-development specifications. They learn how to use Acceptance Test-Driven Development (ATDD) using Behavior-Driven Development (BDD) to create a non-controversial definition of done. It almost eliminates the chance of misunderstandings. By creating this agreement on the Definition of Done before starting the development and testing efforts, many of the dilemmas and resulting problems listed above are prevented outright.

Course Objectives: 

We use a training workshop to teach the fundamentals of ATDD using BDD and BBA, and then coach teams on applying it to their real-life requirements.


The workshop is spaced out over three modules, with the delivery timing of each module being flexible, limited only by availability and travel expenses.


Each of the three modules consists of a half-day of classroom training for everyone attending the workshop, followed by 1 to 1.5 hours of one-on-one coaching for each development team wherein they create actual agreed-upon specifications that will be developed in an upcoming development effort.


Learning Objectives: 

This workshop combines training and coaching to equip the software development triad.

  • Pre-workshop: Half-day meeting with first level management and team-leads to become familiar with your organization and team’s needs.

  • Training: 1.5 days. Principles of Agile requirements;  ATDD, BDD, and BBA; Done criteria, estimation

  • Coaching: 3 hours for each team on a 1-on-1 basis spread over the length of the workshop. Putting principles learned into practice on their backlog.


Recommended Follow-On Coaching
  • Program and Team-level Processes Integration: We highly recommend rounding off this workshop with a day of coaching with your Scrum Masters / Agile Coaches on how to integrate ATDD, BDD, and the BBA process into your existing program and team-level processes, e.g. Sprint/Iteration Readiness, SAFe PI Planning Readiness

  • ATDD Automation: This workshop can be followed up with one to two days of coaching to show you how to automate the testing of ATDD specifications.

Effective Agile Requirements: Acceptance Test-Driven Development with Behavior-Driven Analysis

After completely establishing the strengths and usefulness of the strategies, the course then focuses on how to apply the strategies to new designs, and how to recognize opportunities to use them in your analysis of existing code.


Course Objectives: 

This course teaches participants how to analyze requirements and turn them into an object-oriented program. This is done in a collaborative, efficient manner that minimizes the waste associated with software development which encompasses requirements, specifications, implementation and testing.


Learning Objectives: 

When you have completed this course, you will

  • Know how to use polymorphism in effective ways

  • Have improved your object-oriented analysis skills

  • Be able to identify classes in their problem domain by multiple techniques

  • Be able to read basic UML diagrams

  • Understand which code qualities are essential for writing maintainable code

Effective Object-Oriented Analysis and Design

The value comes because learning good design is an essential part of learning to use design patterns in the course (the focus of Design Patterns Thinking) and in Test-Driven Development (the focus of Sustainable Test-Driven Development).


Course Objectives: 

This course is conducted over five days. In the first three days, we focus on the qualities. principles, and practices of good object-oriented analysis and design using the patterns as guidance. Exercises are done at tables and whiteboards. In the final two days, we teach the sustainable process of TDD through lecture and hands-on coding exercises. Through this process the students learn how TDD leads to patterns, how patterns lead to testability, and how they, together, empower the team to create high-quality software in an efficient and sustainable manner.


Learning Objectives: 

A the end of this course, you will understand the following:

  • What patterns are

  • How patterns lead to testability

  • How TDD leads to patterns

  • How patterns and TDD work together to empower teams

  • How patterns and TDD combine to realize high-quality software efficiently and sustainably

Emergent Design Bundle

There are choices a developer can make that will make the software they write harder to maintain or extend and choices that will make it easier. This course helps developers make better choices for more longevity and flexibility in their code without introducing undue complexity.


This course addresses key questions in modern development such as how to design systems that have changeability as a fundamental quality and how the team can communicate effectively when a design is in a constant state of change.


Find out more at Net Objectives University.


Watch a webinar for An Introduction to Sustainable Design


Course Objectives: 

There are eight sessions in the course, each focused on one aspect of sustainable design. 

In this course, you will:

  • Identify the seven factors of sustainable design.

  • Explore your understanding through guided exercises and discussions with fellow students.

  • Assess your understanding with quizzes for each factor.


Learning Objectives: 

Upon completion, developers should be able to:

  • Identify properties of a design that will limit a product’s shelf life.

  • Propose improvements to extend and expand the usefulness of a software product.

  • Determine when they need to pull in a more experienced software designer.

  • Communicate effectively about design with other developers using a common language.

  • For new code, reduce the incidence of the following:

    • Needing to make the same fix in several places.

    • “Cascading” changes, where one small change leads to another, then another, et cetera.

    • Long searches to determine where all the related parts of a requirement live.

    • Surprising impacts on consumers of code.

    • Writing inscrutable code.

    • Unexpected side-effects within a body of code.

    • Difficulty testing.

Foundations of Sustainable Design

Unless developers are trained about which tests to write, how to write them, when to refactor code, and the techniques for breaking dependencies, testing can become unsustainable as projects mature. We teach how to make Test-Driven Development sustainable with a focus on deriving maximum value (technical and business) from minimal effort and cost.


How TDD relates to ATDD, emergent design, SOLID design principles, and design patterns are also included.


Course Objectives: 

This course teaches participants the sustainable approach to Test-Driven Development. The practice of Test-Driven Development, which utilizes Refactoring and Unit Testing in a particularly fine-grained way, is demonstrated. Hands-on TDD coding will dominate throughout.


Learning Objectives: 

In this course, you will learn:

  • Why and how to be "test-driven"

  • How to analyze requirements to obtain better tests

  • How to write unit tests

  • How to use mock objects

  • How to refactor legacy code

  • How to use an XUnit testing framework (Junit, MSTest, or Jest)

  • A variety of refactoring techniques, with hands-on exercises to solidify this knowledge

Sustainable Test-Driven Development