Practices of Mastery

Quality all_inclusive Velocity

Software teams are constantly pushed to deliver faster and at higher quality. This drive often results in the loss of either quality or velocity, but we cannot make this sacrifice.

The Practices of Mastery help software teams achieve higher quality at higher velocity. They borrow from major software development movements such as Agile, Devops and XP.

The practices are as follows.


  • folder_data Check your code in.
    Sharing code is an opportunity for communication, collaboration and higher overall quality of code.
  • developer_guide Local Conventions.
    From how many minutes late you have to be before you buy coffee to a Java style guide, local conventions help establish the expectations and aid communication in teams.
  • rate_review Code reviews.
    The law of four eyes helps ensure a level of quality, and it's also an opportunity for team mates to learn from, and mentor, each other.
  • bug_report Quality assurance.
    Software exists to satisfy some customer's need. The continuous effort to verify and validate customer value is the assurance of quality in software.


  • build Automated Build.
    Continuous Integration, which can be stated as always having a shippable product, requires that we build our software automatically.
  • quiz Automated Test.
    If we're to ensure that our product is always shippable, we need to ensure we run our tests automatically as part of our Continuous Integration process.
  • deployed_code_update Automated Deployment.
    If our product is always shippable, then we should just ship it. Getting product into the hands of the customer is the quickest way to get feedback about quality.
  • autoplay Automated Infrastructure.
    Software needs other components (application containers, hardware, etc.) to run. As far as possible, we should automate the provisioning of such infrastructure so that we can ensure consistency and so that we can speed up the delivery of value to customers.
  • supervisor_account Automated operations.
    We should always know how our software is performing so that we can be proactive about supporting our software.