General Stuff

Icons made by Freepik from www.flaticon.com is licensed by CC 3.0 BY

Do we have version control of our code in the company's git?

We should have only one code repository to unify tooling and be able to share DevOps scripts and processes.

Do we have documentation for the business process related to our project?

Every team has project-related internal processes like ingestion, content management, cache invalidation, further validations, package signing, how to's, ...

All of this should be documented and accesible so everyone can take care of it anytime, anywhere.

Do we define well-documented PR's so anyone can manually test it?

A well-defined PR should describe at least how to test it manually, so anyone inside/outside the team can check if it works as expected.

Also, the how-to-test can be implemented as part of the US acceptance test.

PR = Pull Request | US = User Story

Do we actually review other members’ Pull-Requests?

It means: clone it, run it, check the acceptance criteria, check UI, check border cases, read the PR code and actually understand it, make questions and accept/reject PRs.

PR = Pull Request

Do we have access to the best tools the budget can afford?

Do we have all the tools/services needed to get our job done?.

 Do we need something that would help us to increase our productivity?.

Do we apply automatic checkers to lint and format our code?

Simple comma or double comma? tabs or spaces? trailing commas? allow arrow functions? allow global declarations?.

Whatever you choose, automate it and let the computer work for you.

Can we launch A/B tests with feature flags?

Does the team care about deploying value behind a feature flag at grooming?.

Do we have tools to apply segmented feature flags?.

Do we have a well defined-onboarding process to new members?

New member onboarding is a critical step in the experience of a new member.

We must ensure they have all info needed to understand our business, how his team works and how they can be productive.

DevOps Stuff

Can we release our project just by "1 click"?

A deploy task is an action triggered by any team member and doesn't need any further action.

Could be a git-tag, a command, a click in a UI.

Can we release our project on-demand?

Our project can be deployed with no downtime.

We are autonomous to deploy whenever the product value is ready.

Is the project dockerized?

The project should be dockerized in order to be deployable in our container-based infraestructure.

Is it possible to create a feature branch environment easily?

Feature branch environments are a core element of our workflow.

We must be able to create, share and test them easily.

Can we apply a project config in runtime?

Usually, projects are bundled with embedded config per environment, but, if we can apply this config in runtime, then, we can share the same bundled artifact across environments with almost zero cost.

QA Stuff

Do we have an acceptance test for each user history?

Do our user stories have well-defined acceptance criteria?.

Can acceptance tests be developed as automated tests?.

Are acceptance test validated with PO and QA?.

Do we have test specs for the project?

Do we implement acceptance criteria as part of the value in the PR?.

Do we implement unit/integration tests for business logic?.

Do we implement functional tests for business value?.

PR = Pull Request

Do we have an up-to-date bug tracking?

Ensure all bugs and issues are identified and tracked so we will not miss it.

There is only a single source of truth for bugs and issues.

Bugs are well defined: how to reproduce it, expected/current behavior and any other needed resource.

Do we have QA members in the team?

Do we have specific QA members that understand the project and work closely with the team?.

Do we have a test report per environment that is accesible to all members of the team?

Out of visibility and transparency.

Show the project health status in terms of tests.

Do we have a coverage report per environment that is accesible to all members of the team?

Out of visibility and transparency.

Show the project health status in terms of tests coverage.

Team has defined coverage threshold.

Do we do user test for new features?

We test our value and validate our hypothesis with real users.

Do we run tests at every commit?

Ensure every commit is deployable to other environments anytime.

Detect errors early so we can fix it ASAP.

Do we run linters at every commit?

Code must follow best practices and formatting as defined in team agreements.

Agile Stuff

Do we have knowledge about the process from de US definition to prod release?

 Team members know user story journey from definition to production, through design, implementation, validation, and deployment.

US = User Story

Do we have a clear vision which is the priority?

Do we have a single source of truth where tasks are listed and prioritized?.

Do we have a goal/focus in every sprint?.

Do we have a WIP limit?.

WIP = Work In Progress

Have we identified and agreed with PO the technical debt of the project?

Technical debt only becomes technical debt if it is identified and must be agreed between the DevTeam and PO.

The technical debt must be expressed in terms of value or impact in the product/business.

Do we have a Definition of Ready (DoR)?

Is the task well defined so it explains what it is, how it works and why we need it?.

Do we have all the things we need to finish the task?.

Can we finish the task in a sprint?.

Does the task have any risk or blocker?.

Is the task estimated in terms of effort/complexity?.

Do we have a Definition of Done (DoD)?

DoD is our commitment to quality baseline.

Should be agreed between PO and DevTeam.

Should identify all checks needed to consider a task done.

Do we have a Definition of Production Ready (DoPR)?

High-performance teams are not only value-oriented, instead, they also provide lasting value.

DoPR ensures we consolidate into main branches only production-ready value, ready to be deployed anytime.

Do we do postmortems after a service downtime?

We must learn from our mistakes.