Friction Log Methodology Vocabulary
Practice friction log vocabulary: developer friction log sessions, time-on-task measurement, friction point categorization, and sprint-level friction reduction language.
0 / 45 completed
1 / 45
What is a 'developer friction log session'?
A friction log session is a structured UX research method adapted for developer tools: a developer completes a real task while narrating their experience, and an observer logs every point of confusion, delay, or frustration as a 'friction point'.
2 / 45
In a friction log, 'time to complete task X' is used to measure:
Time-on-task is a key friction log metric. Measuring how long it actually takes to complete a common task (e.g., set up a local dev environment) reveals bottlenecks that developers may have normalised.
3 / 45
What does it mean when a friction log says 'the developer was stuck here for 4 minutes'?
In friction log analysis, 4 minutes stuck on a single step is a red flag. Friction logs capture these moments precisely to help platform teams prioritise which pain points to fix first.
4 / 45
'Friction point categorization' means:
Categorising friction points helps platform teams identify systemic issues — e.g., if 70% of friction points are 'documentation' issues, that points to a clear investment area rather than scattered individual fixes.
5 / 45
A team reports 'we removed 3 ___ points this sprint.' What word fits?
'Friction points' is the standard term for specific moments of difficulty in developer workflows. Tracking their removal sprint-by-sprint demonstrates measurable DX improvement.
6 / 45
Sarah: "Hey team, I'm logging a friction point with the new authentication flow. It seems like developers are spending a lot of time manually entering their API keys into the config.js file during onboarding. We need to track this to see if it's a systemic issue."This scenario highlights a common use case for friction logs. The phrase 'spending a lot of time' coupled with the manual key entry suggests an inefficiency – a potential friction point. Options A and D minimize the importance of tracking this; option B incorrectly attributes it to a bug requiring immediate escalation (it's an opportunity for improvement), while option C accurately identifies it as a measurable friction point needing investigation. The goal is not to just identify problems, but to quantify their impact.
7 / 45
PR Description:
"@john.doe updated the UserAuthenticationService.js module. Initial friction log entry indicates a high number of developers (3 out of 5) are experiencing delays during the login process, specifically spending an average of 8 minutes manually entering their JWT tokens into the service due to recent changes in the API key management system. We'll need to investigate further."
8 / 45
john.doe wrote the following comment on a PR:
"Okay, I've added logging around the API key retrieval process. Let's see if this helps us identify any friction points in onboarding. I'm expecting to see a high volume of 'failed authentication' events initially as developers are setting up their keys."This is a crucial distinction. John isn't just monitoring API key usage; he's anticipating and logging *expected* troubleshooting – 'failed authentication' events – which are highly likely when developers are initially configuring their keys. This proactive approach aligns with the friction log methodology of identifying and addressing onboarding challenges, not simply reacting to errors. The comment demonstrates an understanding that initial issues are normal and should be logged for analysis.
9 / 45
David: "Hey team, I've just added a new friction log entry for the deployment process. It shows that developers are spending an average of 12 minutes resolving 'connection refused' errors when deploying to our staging environment. We should flag this as a high priority."This question focuses on the practical application of friction logs. While frustration is *a* potential outcome, a friction log's primary purpose is to quantify inefficiencies—like long deployment times—allowing for data-driven prioritization. The incorrect options misinterpret the log's function as primarily focused on morale or minor delays, neglecting its value in identifying systemic problems. It's vital to understand that a high number of minutes spent resolving an error signals a larger issue requiring investigation.
10 / 45
Mark: "Hey team, I'm logging a friction point related to the new GraphQL schema. We're seeing developers spending an average of 6 minutes wrestling with complex queries and pagination errors when fetching user profiles. This is impacting their productivity significantly."This question assesses understanding of the primary purpose of a friction log. While performance metrics are important, a friction log's core function is to capture *developer experience* issues – in this case, complex queries and pagination errors causing significant time investment. The log should facilitate identifying root causes and proposing solutions, not just passively monitoring server performance. Focusing solely on quantitative data misses the critical 'why' behind the problem.
11 / 45
Sarah: "Hey team, I'm logging a friction point with the new authentication flow. It seems like developers are spending a lot of time manually entering their API keys into the config.js file during onboarding. We need to track this to see if it's a systemic issue."This scenario highlights a common use case for friction logs. The phrase 'spending a lot of time' coupled with the manual key entry suggests an inefficiency – a potential friction point. Options A and D minimize the importance of tracking this; option B incorrectly attributes it to a bug requiring immediate escalation (it's an opportunity for improvement), while option C accurately identifies it as a measurable friction point needing investigation. The goal is not to just identify problems, but to quantify their impact.
12 / 45
PR Description:
"@john.doe updated the UserAuthenticationService.js module. Initial friction log entry indicates a high number of developers (3 out of 5) are experiencing delays during the login process, specifically spending an average of 8 minutes manually entering their JWT tokens into the service due to recent changes in the API key management system. We'll need to investigate further."
13 / 45
john.doe wrote the following comment on a PR:
"Okay, I've added logging around the API key retrieval process. Let's see if this helps us identify any friction points in onboarding. I'm expecting to see a high volume of 'failed authentication' events initially as developers are setting up their keys."This is a crucial distinction. John isn't just monitoring API key usage; he's anticipating and logging *expected* troubleshooting – 'failed authentication' events – which are highly likely when developers are initially configuring their keys. This proactive approach aligns with the friction log methodology of identifying and addressing onboarding challenges, not simply reacting to errors. The comment demonstrates an understanding that initial issues are normal and should be logged for analysis.
14 / 45
David: "Hey team, I've just added a new friction log entry for the deployment process. It shows that developers are spending an average of 12 minutes resolving 'connection refused' errors when deploying to our staging environment. We should flag this as a high priority."This question focuses on the practical application of friction logs. While frustration is *a* potential outcome, a friction log's primary purpose is to quantify inefficiencies—like long deployment times—allowing for data-driven prioritization. The incorrect options misinterpret the log's function as primarily focused on morale or minor delays, neglecting its value in identifying systemic problems. It's vital to understand that a high number of minutes spent resolving an error signals a larger issue requiring investigation.
15 / 45
Mark: "Hey team, I'm logging a friction point related to the new GraphQL schema. We're seeing developers spending an average of 6 minutes wrestling with complex queries and pagination errors when fetching user profiles. This is impacting their productivity significantly."This question assesses understanding of the primary purpose of a friction log. While performance metrics are important, a friction log's core function is to capture *developer experience* issues – in this case, complex queries and pagination errors causing significant time investment. The log should facilitate identifying root causes and proposing solutions, not just passively monitoring server performance. Focusing solely on quantitative data misses the critical 'why' behind the problem.
16 / 45
Sarah: "Hey team, I'm logging a friction point with the new authentication flow. It seems like developers are spending a lot of time manually entering their API keys into the config.js file during onboarding. We need to track this to see if it's a systemic issue."This scenario highlights a common use case for friction logs. The phrase 'spending a lot of time' coupled with the manual key entry suggests an inefficiency – a potential friction point. Options A and D minimize the importance of tracking this; option B incorrectly attributes it to a bug requiring immediate escalation (it's an opportunity for improvement), while option C accurately identifies it as a measurable friction point needing investigation. The goal is not to just identify problems, but to quantify their impact.
17 / 45
PR Description:
"@john.doe updated the UserAuthenticationService.js module. Initial friction log entry indicates a high number of developers (3 out of 5) are experiencing delays during the login process, specifically spending an average of 8 minutes manually entering their JWT tokens into the service due to recent changes in the API key management system. We'll need to investigate further."
18 / 45
john.doe wrote the following comment on a PR:
"Okay, I've added logging around the API key retrieval process. Let's see if this helps us identify any friction points in onboarding. I'm expecting to see a high volume of 'failed authentication' events initially as developers are setting up their keys."This is a crucial distinction. John isn't just monitoring API key usage; he's anticipating and logging *expected* troubleshooting – 'failed authentication' events – which are highly likely when developers are initially configuring their keys. This proactive approach aligns with the friction log methodology of identifying and addressing onboarding challenges, not simply reacting to errors. The comment demonstrates an understanding that initial issues are normal and should be logged for analysis.
19 / 45
David: "Hey team, I've just added a new friction log entry for the deployment process. It shows that developers are spending an average of 12 minutes resolving 'connection refused' errors when deploying to our staging environment. We should flag this as a high priority."This question focuses on the practical application of friction logs. While frustration is *a* potential outcome, a friction log's primary purpose is to quantify inefficiencies—like long deployment times—allowing for data-driven prioritization. The incorrect options misinterpret the log's function as primarily focused on morale or minor delays, neglecting its value in identifying systemic problems. It's vital to understand that a high number of minutes spent resolving an error signals a larger issue requiring investigation.
20 / 45
Mark: "Hey team, I'm logging a friction point related to the new GraphQL schema. We're seeing developers spending an average of 6 minutes wrestling with complex queries and pagination errors when fetching user profiles. This is impacting their productivity significantly."This question assesses understanding of the primary purpose of a friction log. While performance metrics are important, a friction log's core function is to capture *developer experience* issues – in this case, complex queries and pagination errors causing significant time investment. The log should facilitate identifying root causes and proposing solutions, not just passively monitoring server performance. Focusing solely on quantitative data misses the critical 'why' behind the problem.
21 / 45
Sarah: "Hey team, I'm logging a friction point with the new authentication flow. It seems like developers are spending a lot of time manually entering their API keys into the config.js file during onboarding. We need to track this to see if it's a systemic issue."This scenario highlights a common use case for friction logs. The phrase 'spending a lot of time' coupled with the manual key entry suggests an inefficiency – a potential friction point. Options A and D minimize the importance of tracking this; option B incorrectly attributes it to a bug requiring immediate escalation (it's an opportunity for improvement), while option C accurately identifies it as a measurable friction point needing investigation. The goal is not to just identify problems, but to quantify their impact.
22 / 45
PR Description:
"@john.doe updated the UserAuthenticationService.js module. Initial friction log entry indicates a high number of developers (3 out of 5) are experiencing delays during the login process, specifically spending an average of 8 minutes manually entering their JWT tokens into the service due to recent changes in the API key management system. We'll need to investigate further."
23 / 45
john.doe wrote the following comment on a PR:
"Okay, I've added logging around the API key retrieval process. Let's see if this helps us identify any friction points in onboarding. I'm expecting to see a high volume of 'failed authentication' events initially as developers are setting up their keys."This is a crucial distinction. John isn't just monitoring API key usage; he's anticipating and logging *expected* troubleshooting – 'failed authentication' events – which are highly likely when developers are initially configuring their keys. This proactive approach aligns with the friction log methodology of identifying and addressing onboarding challenges, not simply reacting to errors. The comment demonstrates an understanding that initial issues are normal and should be logged for analysis.
24 / 45
David: "Hey team, I've just added a new friction log entry for the deployment process. It shows that developers are spending an average of 12 minutes resolving 'connection refused' errors when deploying to our staging environment. We should flag this as a high priority."This question focuses on the practical application of friction logs. While frustration is *a* potential outcome, a friction log's primary purpose is to quantify inefficiencies—like long deployment times—allowing for data-driven prioritization. The incorrect options misinterpret the log's function as primarily focused on morale or minor delays, neglecting its value in identifying systemic problems. It's vital to understand that a high number of minutes spent resolving an error signals a larger issue requiring investigation.
25 / 45
Mark: "Hey team, I'm logging a friction point related to the new GraphQL schema. We're seeing developers spending an average of 6 minutes wrestling with complex queries and pagination errors when fetching user profiles. This is impacting their productivity significantly."This question assesses understanding of the primary purpose of a friction log. While performance metrics are important, a friction log's core function is to capture *developer experience* issues – in this case, complex queries and pagination errors causing significant time investment. The log should facilitate identifying root causes and proposing solutions, not just passively monitoring server performance. Focusing solely on quantitative data misses the critical 'why' behind the problem.
26 / 45
Sarah: "Hey team, I'm logging a friction point with the new authentication flow. It seems like developers are spending a lot of time manually entering their API keys into the config.js file during onboarding. We need to track this to see if it's a systemic issue."This scenario highlights a common use case for friction logs. The phrase 'spending a lot of time' coupled with the manual key entry suggests an inefficiency – a potential friction point. Options A and D minimize the importance of tracking this; option B incorrectly attributes it to a bug requiring immediate escalation (it's an opportunity for improvement), while option C accurately identifies it as a measurable friction point needing investigation. The goal is not to just identify problems, but to quantify their impact.
27 / 45
PR Description:
"@john.doe updated the UserAuthenticationService.js module. Initial friction log entry indicates a high number of developers (3 out of 5) are experiencing delays during the login process, specifically spending an average of 8 minutes manually entering their JWT tokens into the service due to recent changes in the API key management system. We'll need to investigate further."
28 / 45
john.doe wrote the following comment on a PR:
"Okay, I've added logging around the API key retrieval process. Let's see if this helps us identify any friction points in onboarding. I'm expecting to see a high volume of 'failed authentication' events initially as developers are setting up their keys."This is a crucial distinction. John isn't just monitoring API key usage; he's anticipating and logging *expected* troubleshooting – 'failed authentication' events – which are highly likely when developers are initially configuring their keys. This proactive approach aligns with the friction log methodology of identifying and addressing onboarding challenges, not simply reacting to errors. The comment demonstrates an understanding that initial issues are normal and should be logged for analysis.
29 / 45
David: "Hey team, I've just added a new friction log entry for the deployment process. It shows that developers are spending an average of 12 minutes resolving 'connection refused' errors when deploying to our staging environment. We should flag this as a high priority."This question focuses on the practical application of friction logs. While frustration is *a* potential outcome, a friction log's primary purpose is to quantify inefficiencies—like long deployment times—allowing for data-driven prioritization. The incorrect options misinterpret the log's function as primarily focused on morale or minor delays, neglecting its value in identifying systemic problems. It's vital to understand that a high number of minutes spent resolving an error signals a larger issue requiring investigation.
30 / 45
Mark: "Hey team, I'm logging a friction point related to the new GraphQL schema. We're seeing developers spending an average of 6 minutes wrestling with complex queries and pagination errors when fetching user profiles. This is impacting their productivity significantly."This question assesses understanding of the primary purpose of a friction log. While performance metrics are important, a friction log's core function is to capture *developer experience* issues – in this case, complex queries and pagination errors causing significant time investment. The log should facilitate identifying root causes and proposing solutions, not just passively monitoring server performance. Focusing solely on quantitative data misses the critical 'why' behind the problem.
31 / 45
Sarah: "Hey team, I'm logging a friction point with the new authentication flow. It seems like developers are spending a lot of time manually entering their API keys into the config.js file during onboarding. We need to track this to see if it's a systemic issue."This scenario highlights a common use case for friction logs. The phrase 'spending a lot of time' coupled with the manual key entry suggests an inefficiency – a potential friction point. Options A and D minimize the importance of tracking this; option B incorrectly attributes it to a bug requiring immediate escalation (it's an opportunity for improvement), while option C accurately identifies it as a measurable friction point needing investigation. The goal is not to just identify problems, but to quantify their impact.
32 / 45
PR Description:
"@john.doe updated the UserAuthenticationService.js module. Initial friction log entry indicates a high number of developers (3 out of 5) are experiencing delays during the login process, specifically spending an average of 8 minutes manually entering their JWT tokens into the service due to recent changes in the API key management system. We'll need to investigate further."
33 / 45
john.doe wrote the following comment on a PR:
"Okay, I've added logging around the API key retrieval process. Let's see if this helps us identify any friction points in onboarding. I'm expecting to see a high volume of 'failed authentication' events initially as developers are setting up their keys."This is a crucial distinction. John isn't just monitoring API key usage; he's anticipating and logging *expected* troubleshooting – 'failed authentication' events – which are highly likely when developers are initially configuring their keys. This proactive approach aligns with the friction log methodology of identifying and addressing onboarding challenges, not simply reacting to errors. The comment demonstrates an understanding that initial issues are normal and should be logged for analysis.
34 / 45
David: "Hey team, I've just added a new friction log entry for the deployment process. It shows that developers are spending an average of 12 minutes resolving 'connection refused' errors when deploying to our staging environment. We should flag this as a high priority."This question focuses on the practical application of friction logs. While frustration is *a* potential outcome, a friction log's primary purpose is to quantify inefficiencies—like long deployment times—allowing for data-driven prioritization. The incorrect options misinterpret the log's function as primarily focused on morale or minor delays, neglecting its value in identifying systemic problems. It's vital to understand that a high number of minutes spent resolving an error signals a larger issue requiring investigation.
35 / 45
Mark: "Hey team, I'm logging a friction point related to the new GraphQL schema. We're seeing developers spending an average of 6 minutes wrestling with complex queries and pagination errors when fetching user profiles. This is impacting their productivity significantly."This question assesses understanding of the primary purpose of a friction log. While performance metrics are important, a friction log's core function is to capture *developer experience* issues – in this case, complex queries and pagination errors causing significant time investment. The log should facilitate identifying root causes and proposing solutions, not just passively monitoring server performance. Focusing solely on quantitative data misses the critical 'why' behind the problem.
36 / 45
Sarah: "Hey team, I'm logging a friction point with the new authentication flow. It seems like developers are spending a lot of time manually entering their API keys into the config.js file during onboarding. We need to track this to see if it's a systemic issue."This scenario highlights a common use case for friction logs. The phrase 'spending a lot of time' coupled with the manual key entry suggests an inefficiency – a potential friction point. Options A and D minimize the importance of tracking this; option B incorrectly attributes it to a bug requiring immediate escalation (it's an opportunity for improvement), while option C accurately identifies it as a measurable friction point needing investigation. The goal is not to just identify problems, but to quantify their impact.
37 / 45
PR Description:
"@john.doe updated the UserAuthenticationService.js module. Initial friction log entry indicates a high number of developers (3 out of 5) are experiencing delays during the login process, specifically spending an average of 8 minutes manually entering their JWT tokens into the service due to recent changes in the API key management system. We'll need to investigate further."
38 / 45
john.doe wrote the following comment on a PR:
"Okay, I've added logging around the API key retrieval process. Let's see if this helps us identify any friction points in onboarding. I'm expecting to see a high volume of 'failed authentication' events initially as developers are setting up their keys."This is a crucial distinction. John isn't just monitoring API key usage; he's anticipating and logging *expected* troubleshooting – 'failed authentication' events – which are highly likely when developers are initially configuring their keys. This proactive approach aligns with the friction log methodology of identifying and addressing onboarding challenges, not simply reacting to errors. The comment demonstrates an understanding that initial issues are normal and should be logged for analysis.
39 / 45
David: "Hey team, I've just added a new friction log entry for the deployment process. It shows that developers are spending an average of 12 minutes resolving 'connection refused' errors when deploying to our staging environment. We should flag this as a high priority."This question focuses on the practical application of friction logs. While frustration is *a* potential outcome, a friction log's primary purpose is to quantify inefficiencies—like long deployment times—allowing for data-driven prioritization. The incorrect options misinterpret the log's function as primarily focused on morale or minor delays, neglecting its value in identifying systemic problems. It's vital to understand that a high number of minutes spent resolving an error signals a larger issue requiring investigation.
40 / 45
Mark: "Hey team, I'm logging a friction point related to the new GraphQL schema. We're seeing developers spending an average of 6 minutes wrestling with complex queries and pagination errors when fetching user profiles. This is impacting their productivity significantly."This question assesses understanding of the primary purpose of a friction log. While performance metrics are important, a friction log's core function is to capture *developer experience* issues – in this case, complex queries and pagination errors causing significant time investment. The log should facilitate identifying root causes and proposing solutions, not just passively monitoring server performance. Focusing solely on quantitative data misses the critical 'why' behind the problem.
41 / 45
Sarah: "Hey team, I'm logging a friction point with the new authentication flow. It seems like developers are spending a lot of time manually entering their API keys into the config.js file during onboarding. We need to track this to see if it's a systemic issue."This scenario highlights a common use case for friction logs. The phrase 'spending a lot of time' coupled with the manual key entry suggests an inefficiency – a potential friction point. Options A and D minimize the importance of tracking this; option B incorrectly attributes it to a bug requiring immediate escalation (it's an opportunity for improvement), while option C accurately identifies it as a measurable friction point needing investigation. The goal is not to just identify problems, but to quantify their impact.
42 / 45
PR Description:
"@john.doe updated the UserAuthenticationService.js module. Initial friction log entry indicates a high number of developers (3 out of 5) are experiencing delays during the login process, specifically spending an average of 8 minutes manually entering their JWT tokens into the service due to recent changes in the API key management system. We'll need to investigate further."
43 / 45
john.doe wrote the following comment on a PR:
"Okay, I've added logging around the API key retrieval process. Let's see if this helps us identify any friction points in onboarding. I'm expecting to see a high volume of 'failed authentication' events initially as developers are setting up their keys."This is a crucial distinction. John isn't just monitoring API key usage; he's anticipating and logging *expected* troubleshooting – 'failed authentication' events – which are highly likely when developers are initially configuring their keys. This proactive approach aligns with the friction log methodology of identifying and addressing onboarding challenges, not simply reacting to errors. The comment demonstrates an understanding that initial issues are normal and should be logged for analysis.
44 / 45
David: "Hey team, I've just added a new friction log entry for the deployment process. It shows that developers are spending an average of 12 minutes resolving 'connection refused' errors when deploying to our staging environment. We should flag this as a high priority."This question focuses on the practical application of friction logs. While frustration is *a* potential outcome, a friction log's primary purpose is to quantify inefficiencies—like long deployment times—allowing for data-driven prioritization. The incorrect options misinterpret the log's function as primarily focused on morale or minor delays, neglecting its value in identifying systemic problems. It's vital to understand that a high number of minutes spent resolving an error signals a larger issue requiring investigation.
45 / 45
Mark: "Hey team, I'm logging a friction point related to the new GraphQL schema. We're seeing developers spending an average of 6 minutes wrestling with complex queries and pagination errors when fetching user profiles. This is impacting their productivity significantly."This question assesses understanding of the primary purpose of a friction log. While performance metrics are important, a friction log's core function is to capture *developer experience* issues – in this case, complex queries and pagination errors causing significant time investment. The log should facilitate identifying root causes and proposing solutions, not just passively monitoring server performance. Focusing solely on quantitative data misses the critical 'why' behind the problem.
Frequently Asked Questions
What does the "Friction Log Methodology Vocabulary" exercise practise?
Practice friction log vocabulary: developer friction log sessions, time-on-task measurement, friction point categorization, and sprint-level friction reduction language.
How many questions are in this exercise?
This exercise has 45 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 "Friction Log Methodology Vocabulary" 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.