A monitoring dashboard shows: "The p99 latency for the checkout API is 2.3 seconds."
What does "p99 latency" mean?
Percentile latency is more meaningful than average because it captures the tail of the distribution — the slowest requests that real users actually experience. A fast average can hide a badly slow 1%.
Percentile
Meaning
p50
Median — 50% of requests are faster than this
p95
95% of requests complete faster than this — only 5% are slower
p99
99% of requests complete faster — captures "tail latency" affecting 1% of requests
p999
99.9th percentile — used for high-traffic services where 0.1% still = many users
Key vocabulary: tail latency, percentile distribution, mean vs. percentile (mean hides outliers), latency SLO defined at p99.
2 / 30
A performance engineer reports: "Throughput dropped from 8,500 RPS to 3,200 RPS after the deployment."
What does "throughput" measure in a system performance context?
Throughput measures volume capacity — how many requests the service handles per second. It is distinct from latency (time for a single request). A service can have low latency but low throughput (can't handle many concurrent requests) — a key performance trade-off.
Metric
Unit
Measures
Throughput
RPS, TPS (transactions per second)
Volume — how many requests handled per second
Latency
ms, seconds
Speed — how long a single request takes
Saturation point
RPS at which latency begins to rise sharply
The throughput ceiling of the system
3 / 30
A performance engineer says: "We established a performance baseline before starting the optimisation work."
What is a performance baseline?
A performance baseline is a pre-change measurement snapshot. Without it, you cannot quantify improvement ("we reduced p99 by 40%") or detect regression ("p99 has worsened since last deploy"). Baselines enable data-driven performance conversations.
Term
Meaning
performance baseline
Measured metrics snapshot before a change — the reference for before/after comparison
regression testing
Comparing post-change metrics against the baseline to detect performance regressions
baseline deviation alert
An alert triggered when current metrics diverge significantly from the established baseline
performance trending
Tracking metric movement over time to detect gradual degradation
4 / 30
An SRE writes in a post-mortem: "The service experienced performance degradation under load during peak hours."
Which explanation most precisely describes "performance degradation"?
Performance degradation means metrics worsen under load — this often follows a non-linear curve: latency increases slowly at low load, then steeply near the saturation point (the "knee of the curve"). The service remains functional but slower.
Term
Meaning
degradation curve
The shape of latency increase as load grows — initially linear, then steep
capacity knee
The inflection point where degradation becomes non-linear
saturation point
The load level at which the system is fully utilised and can no longer keep up
graceful degradation
The system continues operating at reduced quality rather than failing completely
5 / 30
A monitoring dashboard shows memory utilisation growing linearly from 2 GB to 8 GB over 6 hours without restart.
What does this pattern suggest?
Linear memory growth is the classic memory leak signature: allocations accumulate without being released. This eventually causes OOM (Out of Memory) errors and process crashes, or forces frequent restarts. Compare against healthy patterns:
Memory pattern
Interpretation
Flat line
Healthy — stable memory usage
Sawtooth pattern
GC cycles working correctly — allocate, collect, allocate, collect
Linear growth
Memory leak — objects retained that should be released
Sudden spike
Possible large object allocation or traffic burst — investigate
Reviewer: "This query is taking too long. Can you optimize it?" Developer: "I've added an index to the `user_id` column. Does that help?"
Adding an index is a common performance optimization technique. It allows the database to quickly locate rows matching a specific value in the indexed column. The goal here is to reduce the time it takes to retrieve data by avoiding a full table scan. However, indexes also have maintenance overhead, so they should be used judiciously.
7 / 30
User A (a junior developer): "Hey team, the API response time for `/users` is consistently high – around 1.5 seconds. Any ideas?"
User A's message points towards a potential inefficiency in the API endpoint. While network latency and database load are possible contributors, the consistent high response time suggests that the endpoint itself might be a bottleneck – perhaps it's retrieving too much data or performing inefficient operations.
8 / 30
PR Description: "Implemented caching for frequently accessed user profiles. This should improve response times significantly."
The PR description indicates a caching strategy. Caching involves storing frequently accessed data in a faster medium (like memory) to avoid repeated database queries and thus improve response times. This is a well-established technique for optimizing API performance.
9 / 30
"Yesterday I spent time investigating the slow page load times we're seeing on mobile. Initial observations suggest database query optimization could be a key factor."
The standup update highlights the importance of investigating database queries as a potential cause of slow page loads. This is particularly relevant when considering mobile users, who often have slower network connections and may experience higher load on the database server. It's a systematic approach to identifying performance bottlenecks.
This API response demonstrates high latency (450ms). While a 200 status code indicates success, the significant latency suggests a potential issue. This could be due to server overload, network problems, inefficient database queries, or other factors that are impacting the response time.
11 / 30
Reviewer: "This query is taking too long. Can you optimize it?" Developer: "I've added an index to the `user_id` column. Does that help?"
Adding an index is a common performance optimization technique. It allows the database to quickly locate rows matching a specific value in the indexed column. The goal here is to reduce the time it takes to retrieve data by avoiding a full table scan. However, indexes also have maintenance overhead, so they should be used judiciously.
12 / 30
User A (a junior developer): "Hey team, the API response time for `/users` is consistently high – around 1.5 seconds. Any ideas?"
User A's message points towards a potential inefficiency in the API endpoint. While network latency and database load are possible contributors, the consistent high response time suggests that the endpoint itself might be a bottleneck – perhaps it's retrieving too much data or performing inefficient operations.
13 / 30
PR Description: "Implemented caching for frequently accessed user profiles. This should improve response times significantly."
The PR description indicates a caching strategy. Caching involves storing frequently accessed data in a faster medium (like memory) to avoid repeated database queries and thus improve response times. This is a well-established technique for optimizing API performance.
14 / 30
"Yesterday I spent time investigating the slow page load times we're seeing on mobile. Initial observations suggest database query optimization could be a key factor."
The standup update highlights the importance of investigating database queries as a potential cause of slow page loads. This is particularly relevant when considering mobile users, who often have slower network connections and may experience higher load on the database server. It's a systematic approach to identifying performance bottlenecks.
This API response demonstrates high latency (450ms). While a 200 status code indicates success, the significant latency suggests a potential issue. This could be due to server overload, network problems, inefficient database queries, or other factors that are impacting the response time.
16 / 30
Reviewer: "This query is taking too long. Can you optimize it?" Developer: "I've added an index to the `user_id` column. Does that help?"
Adding an index is a common performance optimization technique. It allows the database to quickly locate rows matching a specific value in the indexed column. The goal here is to reduce the time it takes to retrieve data by avoiding a full table scan. However, indexes also have maintenance overhead, so they should be used judiciously.
17 / 30
User A (a junior developer): "Hey team, the API response time for `/users` is consistently high – around 1.5 seconds. Any ideas?"
User A's message points towards a potential inefficiency in the API endpoint. While network latency and database load are possible contributors, the consistent high response time suggests that the endpoint itself might be a bottleneck – perhaps it's retrieving too much data or performing inefficient operations.
18 / 30
PR Description: "Implemented caching for frequently accessed user profiles. This should improve response times significantly."
The PR description indicates a caching strategy. Caching involves storing frequently accessed data in a faster medium (like memory) to avoid repeated database queries and thus improve response times. This is a well-established technique for optimizing API performance.
19 / 30
"Yesterday I spent time investigating the slow page load times we're seeing on mobile. Initial observations suggest database query optimization could be a key factor."
The standup update highlights the importance of investigating database queries as a potential cause of slow page loads. This is particularly relevant when considering mobile users, who often have slower network connections and may experience higher load on the database server. It's a systematic approach to identifying performance bottlenecks.
This API response demonstrates high latency (450ms). While a 200 status code indicates success, the significant latency suggests a potential issue. This could be due to server overload, network problems, inefficient database queries, or other factors that are impacting the response time.
21 / 30
Reviewer: "This query is taking too long. Can you optimize it?" Developer: "I've added an index to the `user_id` column. Does that help?"
Adding an index is a common performance optimization technique. It allows the database to quickly locate rows matching a specific value in the indexed column. The goal here is to reduce the time it takes to retrieve data by avoiding a full table scan. However, indexes also have maintenance overhead, so they should be used judiciously.
22 / 30
User A (a junior developer): "Hey team, the API response time for `/users` is consistently high – around 1.5 seconds. Any ideas?"
User A's message points towards a potential inefficiency in the API endpoint. While network latency and database load are possible contributors, the consistent high response time suggests that the endpoint itself might be a bottleneck – perhaps it's retrieving too much data or performing inefficient operations.
23 / 30
PR Description: "Implemented caching for frequently accessed user profiles. This should improve response times significantly."
The PR description indicates a caching strategy. Caching involves storing frequently accessed data in a faster medium (like memory) to avoid repeated database queries and thus improve response times. This is a well-established technique for optimizing API performance.
24 / 30
"Yesterday I spent time investigating the slow page load times we're seeing on mobile. Initial observations suggest database query optimization could be a key factor."
The standup update highlights the importance of investigating database queries as a potential cause of slow page loads. This is particularly relevant when considering mobile users, who often have slower network connections and may experience higher load on the database server. It's a systematic approach to identifying performance bottlenecks.
This API response demonstrates high latency (450ms). While a 200 status code indicates success, the significant latency suggests a potential issue. This could be due to server overload, network problems, inefficient database queries, or other factors that are impacting the response time.
26 / 30
Reviewer: "This query is taking too long. Can you optimize it?" Developer: "I've added an index to the `user_id` column. Does that help?"
Adding an index is a common performance optimization technique. It allows the database to quickly locate rows matching a specific value in the indexed column. The goal here is to reduce the time it takes to retrieve data by avoiding a full table scan. However, indexes also have maintenance overhead, so they should be used judiciously.
27 / 30
User A (a junior developer): "Hey team, the API response time for `/users` is consistently high – around 1.5 seconds. Any ideas?"
User A's message points towards a potential inefficiency in the API endpoint. While network latency and database load are possible contributors, the consistent high response time suggests that the endpoint itself might be a bottleneck – perhaps it's retrieving too much data or performing inefficient operations.
28 / 30
PR Description: "Implemented caching for frequently accessed user profiles. This should improve response times significantly."
The PR description indicates a caching strategy. Caching involves storing frequently accessed data in a faster medium (like memory) to avoid repeated database queries and thus improve response times. This is a well-established technique for optimizing API performance.
29 / 30
"Yesterday I spent time investigating the slow page load times we're seeing on mobile. Initial observations suggest database query optimization could be a key factor."
The standup update highlights the importance of investigating database queries as a potential cause of slow page loads. This is particularly relevant when considering mobile users, who often have slower network connections and may experience higher load on the database server. It's a systematic approach to identifying performance bottlenecks.
This API response demonstrates high latency (450ms). While a 200 status code indicates success, the significant latency suggests a potential issue. This could be due to server overload, network problems, inefficient database queries, or other factors that are impacting the response time.
What will I practise in "Performance Metrics Vocabulary"?
This module focuses on Performance Profiling — real workplace phrasing you'll use on the job. It contains 30 scenario-based multiple-choice questions with instant feedback.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free to use with no account or sign-up required.
How many questions does this exercise have?
This module includes 30 questions. Each one gives an immediate right/wrong result plus a full explanation of the correct phrasing.
What happens if I answer a question incorrectly?
You'll see the correct answer highlighted straight away, along with a plain-English explanation of why it's right and why the other options don't fit — mistakes are part of the learning here.
Can I retry the exercise if I want a better score?
Yes — use the 'Try again' button on the results screen to reset your score and go through the questions again. There's no limit on attempts.
Who is this Performance Profiling exercise for?
It's aimed at IT professionals with working English who want to sound more natural and precise around performance profiling — useful whether you're preparing for real conversations at work or just building confidence with the vocabulary.
Do I need an account to track my progress?
No account is needed. Your progress through the exercise is tracked locally in your browser for the current session, and you can replay the module at any time.
How is this different from reading a blog article?
This exercise is an interactive drill that tests and reinforces specific phrasing through multiple-choice questions with instant feedback, while blog articles explain concepts and vocabulary in prose. The two work well together.
Where can I find more Performance Profiling exercises?
See the Performance Profiling hub for more modules like this one, or browse the full Exercises page for other IT-English topics.
Can I complete this exercise on my phone?
Yes — every exercise on CoderSlingo is fully responsive and works on phones and tablets, so you can practise anywhere.