5 exercises — how to explain, present, and discuss the four DORA metrics in engineering reviews and executive meetings.
The 4 DORA metrics
Deployment frequency — how often you ship to production
Lead time for changes — commit to production time
Change failure rate — % of deployments causing incidents
MTTR — Mean Time To Restore after an incident
0 / 25 completed
1 / 25
An engineering director presents to the board: "We've moved from the Low performer tier to the Elite performer tier over the past year — our deployment frequency is now multiple times per day." What does deployment frequency measure, and what is the Elite tier threshold according to DORA research?
Deployment frequency measures how often an organisation successfully releases to production. The four DORA tiers: Elite — on-demand, multiple times per day; High — between once per day and once per week; Medium — between once per week and once per month; Low — fewer than once per month. High deployment frequency correlates with faster feedback loops, lower risk per deployment, and higher team morale. When presenting: "We ship multiple times per day, which puts us in the Elite tier and means each release is small and low-risk." Source: the Accelerate book (Forsgren, Humble, Kim, 2018) and the annual DORA State of DevOps Report.
2 / 25
A CTO reports in a quarterly update: "Our lead time for changes has dropped from two weeks to under four hours — developers are no longer waiting in a queue for manual approval gates." What does lead time for changes measure in the DORA framework?
Lead time for changes measures the time from a code commit being merged to that change running in production — sometimes called "commit-to-deploy time." DORA tiers: Elite — less than one hour; High — one day to one week; Medium — one week to one month; Low — one to six months. Long lead times indicate manual gates, approval bottlenecks, or slow CI pipelines. Key phrase: "Our lead time for changes is currently 45 minutes, which is Elite tier — our CI pipeline and automated approvals are working." From the Accelerate book: lead time is one of the primary levers for organisational agility.
3 / 25
After an incident review, an SRE says: "Our change failure rate spiked to 18% this month — nearly one in five deployments caused a rollback or hotfix." What is the change failure rate, and what does an 18% rate indicate?
Change failure rate (CFR) = the percentage of deployments that cause a failure in production, requiring a hotfix, rollback, or patch. DORA tiers: Elite — 0–5%; High — 5–10%; Medium — 10–15%; Low — 46–60% (counterintuitively, the DORA 2023 report shows Low performers cluster at extremes). At 18%, the team is performing below High tier. Key phrases: "Our CFR is above the High performer threshold — we need to invest in better pre-production testing." and "Every percentage point of change failure rate represents real incident cost." CFR and MTTR are the stability metrics; deployment frequency and lead time are the throughput metrics.
4 / 25
During an incident postmortem, a team lead says: "Our MTTR is currently 45 minutes — that's within the Elite tier and we recovered before most users noticed the outage." What does MTTR stand for in this context, and why does a 45-minute MTTR qualify as Elite?
MTTR = Mean Time To Restore (or Recovery) — the average time from when an incident begins to when service is fully restored. DORA tiers: Elite — less than one hour; High — less than one day; Medium — less than one week; Low — more than one week. At 45 minutes, the team is in the Elite tier. MTTR is improved by: runbooks, automated rollback, observability tooling, and on-call response processes. Key executive presentation phrase: "Our MTTR is 45 minutes on average — for a service with this traffic level, that translates to roughly $12k of recovered revenue per incident compared to our previous 4-hour MTTR." Note: MTTR is also used in hardware contexts (Mean Time To Repair); in software/SRE it always means Mean Time To Restore.
5 / 25
A VP of Engineering reads from the Accelerate book in a team meeting: "The research shows that software delivery performance predicts organisational performance — high-performing teams have better profitability, market share, and productivity." Which statement best describes the core argument of the Accelerate book by Forsgren, Humble, and Kim?
Accelerate: The Science of Lean Software and DevOps (Forsgren, Humble, Kim, 2018) presents four years of research showing that the four DORA metrics — deployment frequency, lead time for changes, change failure rate, and MTTR — form two clusters: throughput (speed of delivery) and stability (quality of delivery). Crucially, the research proves that high throughput and high stability are not in tension — Elite teams achieve both simultaneously. This directly contradicts the idea that you must sacrifice quality for speed. Executive-friendly framing: "The Accelerate research demonstrates that investing in engineering effectiveness is not a cost — it's a predictor of revenue growth and market share." Key vocabulary from the book: value stream mapping, deployment pipeline, trunk-based development, loosely coupled architecture, westrum organisational culture.
6 / 25
Liam: "Hey team, I just reviewed this PR. The developer time to deliver was 8 hours – that's pretty high for a simple fix. Should we be tracking how long it takes us to complete tasks?"
Liam correctly identifies the importance of tracking developer time, as it directly relates to efficiency. However, the question aims to test understanding of *how* this aligns with DORA metrics. Developer time is a key input into calculating Lead Time for Changes and Cycle Time – important DORA metrics that reflect how long it takes from code commit to production deployment. It's not a metric in itself like Deployment Frequency or Change Failure Rate, but rather a component used to understand the broader system.
7 / 25
David: "Hey team, I just got this API response back from the backend. The average time to first byte is 1.2 seconds – that's way above our target of 0.5 seconds! We need to investigate latency."
What metric does David primarily highlight in his comment, and why is a high average time to first byte (TTFB) a significant concern for developers?
David is focusing on Time to First Byte (TTFB), which measures the total time it takes for a browser to receive the first byte of data from a server. A high TTFB indicates potential issues with server response times, network connectivity, or even problems within the application itself – these can significantly impact perceived performance and user experience. Choosing option A is correct because TTFB directly reflects server responsiveness; options B, C, and D misinterpret TTFB's meaning.
8 / 25
David is observing the API response time. He's focusing on the average time to first byte (TTFB). Why is a high TTFB a significant concern for developers? Consider the impact on user experience and potential performance bottlenecks.
David is highlighting Time To First Byte (TTFB), which measures the time it takes for the server to respond to the initial request. A high TTFB (over 0.5 seconds in this example) indicates significant latency – essentially, a delay before any data starts being sent from the server. This directly impacts user experience, as users perceive slow loading times negatively and can lead to frustration or abandonment of the application. The other options represent potential causes for *some* latency but don't specifically address the immediate metric David is tracking.
9 / 25
Liam: "Hey team, I just reviewed this PR. The developer time to deliver was 8 hours – that's pretty high for a simple fix. Should we be tracking how long it takes us to complete tasks?"
Liam correctly identifies the importance of tracking developer time, as it directly relates to efficiency. However, the question aims to test understanding of *how* this aligns with DORA metrics. Developer time is a key input into calculating Lead Time for Changes and Cycle Time – important DORA metrics that reflect how long it takes from code commit to production deployment. It's not a metric in itself like Deployment Frequency or Change Failure Rate, but rather a component used to understand the broader system.
10 / 25
David: "Hey team, I just got this API response back from the backend. The average time to first byte is 1.2 seconds – that's way above our target of 0.5 seconds! We need to investigate latency."
What metric does David primarily highlight in his comment, and why is a high average time to first byte (TTFB) a significant concern for developers?
David is focusing on Time to First Byte (TTFB), which measures the total time it takes for a browser to receive the first byte of data from a server. A high TTFB indicates potential issues with server response times, network connectivity, or even problems within the application itself – these can significantly impact perceived performance and user experience. Choosing option A is correct because TTFB directly reflects server responsiveness; options B, C, and D misinterpret TTFB's meaning.
11 / 25
David is observing the API response time. He's focusing on the average time to first byte (TTFB). Why is a high TTFB a significant concern for developers? Consider the impact on user experience and potential performance bottlenecks.
David is highlighting Time To First Byte (TTFB), which measures the time it takes for the server to respond to the initial request. A high TTFB (over 0.5 seconds in this example) indicates significant latency – essentially, a delay before any data starts being sent from the server. This directly impacts user experience, as users perceive slow loading times negatively and can lead to frustration or abandonment of the application. The other options represent potential causes for *some* latency but don't specifically address the immediate metric David is tracking.
12 / 25
Liam: "Hey team, I just reviewed this PR. The developer time to deliver was 8 hours – that's pretty high for a simple fix. Should we be tracking how long it takes us to complete tasks?"
Liam correctly identifies the importance of tracking developer time, as it directly relates to efficiency. However, the question aims to test understanding of *how* this aligns with DORA metrics. Developer time is a key input into calculating Lead Time for Changes and Cycle Time – important DORA metrics that reflect how long it takes from code commit to production deployment. It's not a metric in itself like Deployment Frequency or Change Failure Rate, but rather a component used to understand the broader system.
13 / 25
David: "Hey team, I just got this API response back from the backend. The average time to first byte is 1.2 seconds – that's way above our target of 0.5 seconds! We need to investigate latency."
What metric does David primarily highlight in his comment, and why is a high average time to first byte (TTFB) a significant concern for developers?
David is focusing on Time to First Byte (TTFB), which measures the total time it takes for a browser to receive the first byte of data from a server. A high TTFB indicates potential issues with server response times, network connectivity, or even problems within the application itself – these can significantly impact perceived performance and user experience. Choosing option A is correct because TTFB directly reflects server responsiveness; options B, C, and D misinterpret TTFB's meaning.
14 / 25
David is observing the API response time. He's focusing on the average time to first byte (TTFB). Why is a high TTFB a significant concern for developers? Consider the impact on user experience and potential performance bottlenecks.
David is highlighting Time To First Byte (TTFB), which measures the time it takes for the server to respond to the initial request. A high TTFB (over 0.5 seconds in this example) indicates significant latency – essentially, a delay before any data starts being sent from the server. This directly impacts user experience, as users perceive slow loading times negatively and can lead to frustration or abandonment of the application. The other options represent potential causes for *some* latency but don't specifically address the immediate metric David is tracking.
15 / 25
Liam: "Hey team, I just reviewed this PR. The developer time to deliver was 8 hours – that's pretty high for a simple fix. Should we be tracking how long it takes us to complete tasks?"
Liam correctly identifies the importance of tracking developer time, as it directly relates to efficiency. However, the question aims to test understanding of *how* this aligns with DORA metrics. Developer time is a key input into calculating Lead Time for Changes and Cycle Time – important DORA metrics that reflect how long it takes from code commit to production deployment. It's not a metric in itself like Deployment Frequency or Change Failure Rate, but rather a component used to understand the broader system.
16 / 25
David: "Hey team, I just got this API response back from the backend. The average time to first byte is 1.2 seconds – that's way above our target of 0.5 seconds! We need to investigate latency."
What metric does David primarily highlight in his comment, and why is a high average time to first byte (TTFB) a significant concern for developers?
David is focusing on Time to First Byte (TTFB), which measures the total time it takes for a browser to receive the first byte of data from a server. A high TTFB indicates potential issues with server response times, network connectivity, or even problems within the application itself – these can significantly impact perceived performance and user experience. Choosing option A is correct because TTFB directly reflects server responsiveness; options B, C, and D misinterpret TTFB's meaning.
17 / 25
David is observing the API response time. He's focusing on the average time to first byte (TTFB). Why is a high TTFB a significant concern for developers? Consider the impact on user experience and potential performance bottlenecks.
David is highlighting Time To First Byte (TTFB), which measures the time it takes for the server to respond to the initial request. A high TTFB (over 0.5 seconds in this example) indicates significant latency – essentially, a delay before any data starts being sent from the server. This directly impacts user experience, as users perceive slow loading times negatively and can lead to frustration or abandonment of the application. The other options represent potential causes for *some* latency but don't specifically address the immediate metric David is tracking.
18 / 25
Liam: "Hey team, I just reviewed this PR. The developer time to deliver was 8 hours – that's pretty high for a simple fix. Should we be tracking how long it takes us to complete tasks?"
Liam correctly identifies the importance of tracking developer time, as it directly relates to efficiency. However, the question aims to test understanding of *how* this aligns with DORA metrics. Developer time is a key input into calculating Lead Time for Changes and Cycle Time – important DORA metrics that reflect how long it takes from code commit to production deployment. It's not a metric in itself like Deployment Frequency or Change Failure Rate, but rather a component used to understand the broader system.
19 / 25
David: "Hey team, I just got this API response back from the backend. The average time to first byte is 1.2 seconds – that's way above our target of 0.5 seconds! We need to investigate latency."
What metric does David primarily highlight in his comment, and why is a high average time to first byte (TTFB) a significant concern for developers?
David is focusing on Time to First Byte (TTFB), which measures the total time it takes for a browser to receive the first byte of data from a server. A high TTFB indicates potential issues with server response times, network connectivity, or even problems within the application itself – these can significantly impact perceived performance and user experience. Choosing option A is correct because TTFB directly reflects server responsiveness; options B, C, and D misinterpret TTFB's meaning.
20 / 25
David is observing the API response time. He's focusing on the average time to first byte (TTFB). Why is a high TTFB a significant concern for developers? Consider the impact on user experience and potential performance bottlenecks.
David is highlighting Time To First Byte (TTFB), which measures the time it takes for the server to respond to the initial request. A high TTFB (over 0.5 seconds in this example) indicates significant latency – essentially, a delay before any data starts being sent from the server. This directly impacts user experience, as users perceive slow loading times negatively and can lead to frustration or abandonment of the application. The other options represent potential causes for *some* latency but don't specifically address the immediate metric David is tracking.
21 / 25
Sarah is presenting a summary of the team's DORA metrics during a standup. She highlights that 'Cycle Time' has been consistently high for the last two sprints. Which of the following best explains why this metric is important to discuss with the development team, and what action might be appropriate?
Cycle Time (or Lead Time) is a core DORA metric that reflects the entire process of delivering value. High Cycle Time often points to inefficiencies in processes like testing, deployment, or requirement gathering. Addressing this requires investigation into these bottlenecks, not simply blaming developers.
22 / 25
Mark, a senior developer, posts the following comment on a code review: 'This PR took 6 hours. It's far longer than it should be for a simple UI change. We need to understand why.' What aspect of Developer Experience is Mark primarily addressing when he raises this concern? Consider the impact on efficiency and potential roadblocks.
Mark's comment focuses on 'Developer Time to Deliver,' which directly relates to efficiency. High time-to-deliver can indicate issues with task breakdown, process complexity, or impediments that slow down development progress. This metric is a key component of DORA and helps identify areas for improvement.
23 / 25
Elena receives the following Slack message from a QA engineer: 'The automated tests are failing consistently on our staging environment. The average test execution time is exceeding 30 seconds.' Considering DORA metrics and its implications, what should Elena prioritize investigating first?
Test execution time is a critical component of DORA's 'Lead Time for Changes' metric. Slow test times indicate potential issues within the testing process itself – poorly written tests, inefficient test suites, or resource constraints. Addressing this directly improves lead time.
24 / 25
During a PR review, Ben notes: 'The deployment pipeline takes over 20 minutes to deploy this change to production.' Considering DORA metrics and the impact on developer velocity, what is the MOST immediate concern he should address?
Deployment frequency is a key DORA metric. A long deployment pipeline directly impacts this value, slowing down the delivery of new features and updates. A slow pipeline hinders development velocity and represents a significant bottleneck within the DevOps process.
25 / 25
You are analyzing API response times for a mobile application. The backend service consistently returns responses with a TTFB (Time To First Byte) of 2.5 seconds. Based on DORA metrics and what this indicates about the developer experience, which action would be most appropriate to take immediately?
A high TTFB often signals inefficiencies within the backend infrastructure. Caching is a common and effective technique to reduce latency by serving frequently accessed data directly from memory. Addressing this directly improves response times and contributes positively to Lead Time for Changes.
What does the "DORA Metrics Communication Language" exercise practise?
Practice how to discuss DORA metrics in English: deployment frequency, lead time for changes, change failure rate, MTTR, and how to present them to executives.
How many questions are in this exercise?
This exercise has 25 questions, each multiple-choice with a full explanation shown after you answer.
What English level is this exercise for?
This exercise is tagged Intermediate. If the vocabulary feels difficult, browse the Developer Experience Metrics category page for an easier module to start with.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free with no account, sign-up, or paywall.
Do I get feedback if I answer incorrectly?
Yes — whichever option you choose, right or wrong, you'll immediately see an explanation clarifying the correct term and why the other options don't fit.
Can I retry this exercise?
Yes — once you finish all the questions, a "Try again" button on the results screen resets the exercise so you can practise as many times as you like.
Do I need an account to track my progress?
No account is required. Your progress bar and score for this session are tracked in the browser as you go, but nothing is saved once you leave the page.
Is "DORA Metrics Communication Language" part of a larger series?
Yes — it's one exercise in the Developer Experience Metrics category on CoderSlingo. See the category page for the full list of related exercises on similar terminology.
Can I link directly to this exercise?
Yes — this exercise has its own permanent URL, so you can bookmark it or share the link directly with a colleague or study partner.
Where can I find more exercises like this one?
See the Developer Experience Metrics category page for related exercises, or browse the main Exercises hub for other IT English topics.