Practical Consensus Vocabulary
Practice practical consensus vocabulary: quorum fault tolerance, fencing tokens, lease expiry, and etcd/Zookeeper/Consul usage in production systems.
0 / 41 completed
1 / 41
'The cluster can tolerate 2 node failures with a 5-node quorum.' Why 2?
With N=5 nodes, a majority quorum requires 3 nodes (⌊5/2⌋+1). The cluster can lose 5−3=2 nodes and still have enough nodes to elect a leader and commit writes. Losing 3 nodes means quorum is lost and the cluster becomes unavailable.
2 / 41
What is a 'fencing token' and why is it used?
Fencing tokens prevent the 'zombie leader' problem: a slow node thinks it still holds a lock but is actually expired. Every write includes the fencing token; if the token is older than the current one, the storage layer rejects it — ensuring only the current leader can write.
3 / 41
'The lease expired — waiting for a new leader' means:
A leader lease has a TTL. If the leader fails to send heartbeats (e.g., due to a pause or network issue), the lease expires. Other nodes detect this and start an election. During the gap between lease expiry and new leader election, the cluster may be briefly unavailable for writes.
4 / 41
Which tool is most commonly used as the consensus store in Kubernetes clusters?
etcd is the distributed key-value store at the heart of Kubernetes: it stores all cluster state (pods, services, configs). etcd uses the Raft consensus algorithm to ensure cluster state is consistent across the control plane, even during node failures.
5 / 41
A team says 'we use ___ for service discovery and distributed locking in our microservices.' Which consensus-based tool fits?
Consul (by HashiCorp) provides service discovery, health checking, key-value storage, and distributed locking — all built on the Raft consensus algorithm. It is a common choice for microservices infrastructure alongside etcd and ZooKeeper.
6 / 41
Sarah: "Hey team, I'm seeing a lot of 'stalestack' errors in the API gateway. It seems like requests are getting stuck because we're not consistently acknowledging them. Should we implement a dead letter queue for these failed requests?"Stalestacks in an API gateway represent requests that have been waiting too long without acknowledgment – often due to a bottleneck or transient issue. A dead letter queue (DLQ) is the appropriate solution here because it guarantees all messages will be processed eventually, even if they fail repeatedly; this prevents data loss and provides visibility into persistent issues. The other options misinterpret the cause of stalestacks or suggest inappropriate solutions for the problem.
7 / 41
PR Description:
Subject: Fix: Prevent duplicate order submissions after payment failure.
Details:
We've observed users submitting duplicate orders immediately following a payment failure. This is due to the lack of a robust mechanism to prevent retry attempts when the initial transaction fails. The current implementation simply retries the entire process, leading to double-ordering. This PR introduces a 'circuit breaker' pattern - if an order submission fails after one attempt, we will temporarily halt all subsequent attempts for 30 seconds before reattempting. This reduces the chance of duplicate submissions while still allowing the user to retry.
What does 'circuit breaker' mean in this context?This question tests understanding of a common pattern in resilient systems. A 'circuit breaker' doesn't simply retry an operation; it *pauses* the process when a failure is detected, preventing the system from repeatedly attempting to fail and potentially causing further issues. Option B accurately describes this behavior – it's about temporarily stopping operations to allow for recovery and avoid cascading failures. Options A, C, and D represent unrelated concepts within software development.
8 / 41
John: 'I'm getting a lot of complaints about slow response times from the user service. It seems like requests are queuing up because we haven't implemented a strong consensus mechanism to ensure data consistency across our services. We need something that guarantees everyone is on the same page.' Considering John's feedback, which of these approaches would MOST effectively address this issue?The question highlights a common issue in distributed systems: ensuring data consistency when multiple services are updating the same information. John is correctly identifying that a standard mutex lock won't scale across many instances. A DLT like Raft provides a proven consensus algorithm – guaranteeing all nodes agree on the state, preventing conflicting updates and therefore the queuing problem. Optimistic locking and eventual consistency are also poor choices for this scenario as they don't actively manage potential conflicts.
9 / 41
Consider this Slack message from a developer during a troubleshooting session:
`@johndoe I'm seeing a lot of inconsistencies in the inventory data. We've deployed a new microservice that updates stock levels, and it seems like sometimes we get conflicting updates – one service says we have 10 items in stock, while another shows 5. This is causing problems with our order fulfillment process.`
Which of the following approaches would MOST directly address this issue by ensuring data consistency across the two services?
The core problem is conflicting updates to a shared resource. A mutex lock would only provide limited protection against race conditions. Introducing a distributed consensus algorithm like Raft or Paxos provides strong consistency guarantees by ensuring that all participating services agree on the single, authoritative state of the inventory data before any changes are applied – this directly addresses the root cause of the inconsistencies. Polling and assigning a master service don't inherently solve the problem of divergent updates.
10 / 41
Sarah: "Hey team, I'm seeing a lot of 'stalestack' errors in the API gateway. It seems like requests are getting stuck because we're not consistently acknowledging them. Should we implement a dead letter queue for these failed requests?"Stalestacks in an API gateway represent requests that have been waiting too long without acknowledgment – often due to a bottleneck or transient issue. A dead letter queue (DLQ) is the appropriate solution here because it guarantees all messages will be processed eventually, even if they fail repeatedly; this prevents data loss and provides visibility into persistent issues. The other options misinterpret the cause of stalestacks or suggest inappropriate solutions for the problem.
11 / 41
PR Description:
Subject: Fix: Prevent duplicate order submissions after payment failure.
Details:
We've observed users submitting duplicate orders immediately following a payment failure. This is due to the lack of a robust mechanism to prevent retry attempts when the initial transaction fails. The current implementation simply retries the entire process, leading to double-ordering. This PR introduces a 'circuit breaker' pattern - if an order submission fails after one attempt, we will temporarily halt all subsequent attempts for 30 seconds before reattempting. This reduces the chance of duplicate submissions while still allowing the user to retry.
What does 'circuit breaker' mean in this context?This question tests understanding of a common pattern in resilient systems. A 'circuit breaker' doesn't simply retry an operation; it *pauses* the process when a failure is detected, preventing the system from repeatedly attempting to fail and potentially causing further issues. Option B accurately describes this behavior – it's about temporarily stopping operations to allow for recovery and avoid cascading failures. Options A, C, and D represent unrelated concepts within software development.
12 / 41
John: 'I'm getting a lot of complaints about slow response times from the user service. It seems like requests are queuing up because we haven't implemented a strong consensus mechanism to ensure data consistency across our services. We need something that guarantees everyone is on the same page.' Considering John's feedback, which of these approaches would MOST effectively address this issue?The question highlights a common issue in distributed systems: ensuring data consistency when multiple services are updating the same information. John is correctly identifying that a standard mutex lock won't scale across many instances. A DLT like Raft provides a proven consensus algorithm – guaranteeing all nodes agree on the state, preventing conflicting updates and therefore the queuing problem. Optimistic locking and eventual consistency are also poor choices for this scenario as they don't actively manage potential conflicts.
13 / 41
Consider this Slack message from a developer during a troubleshooting session:
`@johndoe I'm seeing a lot of inconsistencies in the inventory data. We've deployed a new microservice that updates stock levels, and it seems like sometimes we get conflicting updates – one service says we have 10 items in stock, while another shows 5. This is causing problems with our order fulfillment process.`
Which of the following approaches would MOST directly address this issue by ensuring data consistency across the two services?
The core problem is conflicting updates to a shared resource. A mutex lock would only provide limited protection against race conditions. Introducing a distributed consensus algorithm like Raft or Paxos provides strong consistency guarantees by ensuring that all participating services agree on the single, authoritative state of the inventory data before any changes are applied – this directly addresses the root cause of the inconsistencies. Polling and assigning a master service don't inherently solve the problem of divergent updates.
14 / 41
Sarah: "Hey team, I'm seeing a lot of 'stalestack' errors in the API gateway. It seems like requests are getting stuck because we're not consistently acknowledging them. Should we implement a dead letter queue for these failed requests?"Stalestacks in an API gateway represent requests that have been waiting too long without acknowledgment – often due to a bottleneck or transient issue. A dead letter queue (DLQ) is the appropriate solution here because it guarantees all messages will be processed eventually, even if they fail repeatedly; this prevents data loss and provides visibility into persistent issues. The other options misinterpret the cause of stalestacks or suggest inappropriate solutions for the problem.
15 / 41
PR Description:
Subject: Fix: Prevent duplicate order submissions after payment failure.
Details:
We've observed users submitting duplicate orders immediately following a payment failure. This is due to the lack of a robust mechanism to prevent retry attempts when the initial transaction fails. The current implementation simply retries the entire process, leading to double-ordering. This PR introduces a 'circuit breaker' pattern - if an order submission fails after one attempt, we will temporarily halt all subsequent attempts for 30 seconds before reattempting. This reduces the chance of duplicate submissions while still allowing the user to retry.
What does 'circuit breaker' mean in this context?This question tests understanding of a common pattern in resilient systems. A 'circuit breaker' doesn't simply retry an operation; it *pauses* the process when a failure is detected, preventing the system from repeatedly attempting to fail and potentially causing further issues. Option B accurately describes this behavior – it's about temporarily stopping operations to allow for recovery and avoid cascading failures. Options A, C, and D represent unrelated concepts within software development.
16 / 41
John: 'I'm getting a lot of complaints about slow response times from the user service. It seems like requests are queuing up because we haven't implemented a strong consensus mechanism to ensure data consistency across our services. We need something that guarantees everyone is on the same page.' Considering John's feedback, which of these approaches would MOST effectively address this issue?The question highlights a common issue in distributed systems: ensuring data consistency when multiple services are updating the same information. John is correctly identifying that a standard mutex lock won't scale across many instances. A DLT like Raft provides a proven consensus algorithm – guaranteeing all nodes agree on the state, preventing conflicting updates and therefore the queuing problem. Optimistic locking and eventual consistency are also poor choices for this scenario as they don't actively manage potential conflicts.
17 / 41
Consider this Slack message from a developer during a troubleshooting session:
`@johndoe I'm seeing a lot of inconsistencies in the inventory data. We've deployed a new microservice that updates stock levels, and it seems like sometimes we get conflicting updates – one service says we have 10 items in stock, while another shows 5. This is causing problems with our order fulfillment process.`
Which of the following approaches would MOST directly address this issue by ensuring data consistency across the two services?
The core problem is conflicting updates to a shared resource. A mutex lock would only provide limited protection against race conditions. Introducing a distributed consensus algorithm like Raft or Paxos provides strong consistency guarantees by ensuring that all participating services agree on the single, authoritative state of the inventory data before any changes are applied – this directly addresses the root cause of the inconsistencies. Polling and assigning a master service don't inherently solve the problem of divergent updates.
18 / 41
Sarah: "Hey team, I'm seeing a lot of 'stalestack' errors in the API gateway. It seems like requests are getting stuck because we're not consistently acknowledging them. Should we implement a dead letter queue for these failed requests?"Stalestacks in an API gateway represent requests that have been waiting too long without acknowledgment – often due to a bottleneck or transient issue. A dead letter queue (DLQ) is the appropriate solution here because it guarantees all messages will be processed eventually, even if they fail repeatedly; this prevents data loss and provides visibility into persistent issues. The other options misinterpret the cause of stalestacks or suggest inappropriate solutions for the problem.
19 / 41
PR Description:
Subject: Fix: Prevent duplicate order submissions after payment failure.
Details:
We've observed users submitting duplicate orders immediately following a payment failure. This is due to the lack of a robust mechanism to prevent retry attempts when the initial transaction fails. The current implementation simply retries the entire process, leading to double-ordering. This PR introduces a 'circuit breaker' pattern - if an order submission fails after one attempt, we will temporarily halt all subsequent attempts for 30 seconds before reattempting. This reduces the chance of duplicate submissions while still allowing the user to retry.
What does 'circuit breaker' mean in this context?This question tests understanding of a common pattern in resilient systems. A 'circuit breaker' doesn't simply retry an operation; it *pauses* the process when a failure is detected, preventing the system from repeatedly attempting to fail and potentially causing further issues. Option B accurately describes this behavior – it's about temporarily stopping operations to allow for recovery and avoid cascading failures. Options A, C, and D represent unrelated concepts within software development.
20 / 41
John: 'I'm getting a lot of complaints about slow response times from the user service. It seems like requests are queuing up because we haven't implemented a strong consensus mechanism to ensure data consistency across our services. We need something that guarantees everyone is on the same page.' Considering John's feedback, which of these approaches would MOST effectively address this issue?The question highlights a common issue in distributed systems: ensuring data consistency when multiple services are updating the same information. John is correctly identifying that a standard mutex lock won't scale across many instances. A DLT like Raft provides a proven consensus algorithm – guaranteeing all nodes agree on the state, preventing conflicting updates and therefore the queuing problem. Optimistic locking and eventual consistency are also poor choices for this scenario as they don't actively manage potential conflicts.
21 / 41
Consider this Slack message from a developer during a troubleshooting session:
`@johndoe I'm seeing a lot of inconsistencies in the inventory data. We've deployed a new microservice that updates stock levels, and it seems like sometimes we get conflicting updates – one service says we have 10 items in stock, while another shows 5. This is causing problems with our order fulfillment process.`
Which of the following approaches would MOST directly address this issue by ensuring data consistency across the two services?
The core problem is conflicting updates to a shared resource. A mutex lock would only provide limited protection against race conditions. Introducing a distributed consensus algorithm like Raft or Paxos provides strong consistency guarantees by ensuring that all participating services agree on the single, authoritative state of the inventory data before any changes are applied – this directly addresses the root cause of the inconsistencies. Polling and assigning a master service don't inherently solve the problem of divergent updates.
22 / 41
Reviewer: "This commit introduces a new `consensus_update` function, but it doesn't handle potential conflicts. What's the best way to ensure data integrity when multiple services are simultaneously updating the same record?"
Which of the following approaches would be MOST appropriate?
Optimistic locking is a good strategy – it avoids blocking other operations. However, the question asks for the *most* appropriate, and a simple 'last-write-wins' approach is prone to data loss if updates happen very quickly. Ignoring conflicts isn't a robust solution; distributed locks are more complex but provide stronger guarantees against corruption.
23 / 41
"@alice I'm seeing significant latency when querying the user profile service. The logs show multiple requests to the consensus database for each profile update. What could be causing this?"
Alice replies: "Perhaps we should investigate if our current implementation is using a full read of the entire consensus state instead of just the changes."
Alice's suggestion highlights a critical inefficiency: reading the entire consensus state on *every* update. A more targeted approach—only retrieving the changes—significantly reduces the amount of data transferred and processed, directly addressing the latency issue.
24 / 41
The following API response is received after a request to update a user's address using a consensus service:
`{
"status": "error",
"message": "Conflict: Another update to this record has been made concurrently."
}`
What does this response primarily indicate about the system's architecture and data management?
This response strongly suggests the use of MVCC. MVCC allows multiple clients to read and update data concurrently without blocking each other – a conflict message arises when these updates try to modify the same record simultaneously. The other options are less likely based on the error message.
25 / 41
Subject: Improve data consistency in inventory microservice.
Details:
"We've identified a situation where updates to inventory levels are sometimes lost due to race conditions. To mitigate this, we're implementing a quorum-based consensus algorithm using Raft. This will ensure that all nodes agree on the state of the inventory before any changes are persisted."
Which of the following statements BEST summarizes the core benefit of using a quorum-based consensus algorithm in this scenario?
Quorum-based consensus (like Raft) prioritizes reliability and consistency. It achieves this by requiring a majority of nodes to agree on an update before it's committed, providing resilience against failures. The other options are not the primary benefit – immediate propagation is often slower than guaranteed consistency; simplification isn't inherent in the design; manual conflict resolution remains possible.
26 / 41
"Sarah: 'I'm seeing a lot of timeouts when processing transactions through the payment gateway. It seems like we're not consistently acknowledging requests to the consensus ledger before submitting them to the external payment processor.' What should we do?'
Acknowledging requests to the consensus ledger is crucial for reliable transaction processing. The system needs confirmation from the ledger that a request has been recorded before submitting it to the external processor – otherwise, the payment could be processed twice if the acknowledgement is lost.
27 / 41
Reviewer: "This commit introduces a new `consensus_update` function, but it doesn't handle potential conflicts. What's the best way to ensure data integrity when multiple services are simultaneously updating the same record?"
Which of the following approaches would be MOST appropriate?
Optimistic locking is a good strategy – it avoids blocking other operations. However, the question asks for the *most* appropriate, and a simple 'last-write-wins' approach is prone to data loss if updates happen very quickly. Ignoring conflicts isn't a robust solution; distributed locks are more complex but provide stronger guarantees against corruption.
28 / 41
"@alice I'm seeing significant latency when querying the user profile service. The logs show multiple requests to the consensus database for each profile update. What could be causing this?"
Alice replies: "Perhaps we should investigate if our current implementation is using a full read of the entire consensus state instead of just the changes."
Alice's suggestion highlights a critical inefficiency: reading the entire consensus state on *every* update. A more targeted approach—only retrieving the changes—significantly reduces the amount of data transferred and processed, directly addressing the latency issue.
29 / 41
The following API response is received after a request to update a user's address using a consensus service:
`{
"status": "error",
"message": "Conflict: Another update to this record has been made concurrently."
}`
What does this response primarily indicate about the system's architecture and data management?
This response strongly suggests the use of MVCC. MVCC allows multiple clients to read and update data concurrently without blocking each other – a conflict message arises when these updates try to modify the same record simultaneously. The other options are less likely based on the error message.
30 / 41
Subject: Improve data consistency in inventory microservice.
Details:
"We've identified a situation where updates to inventory levels are sometimes lost due to race conditions. To mitigate this, we're implementing a quorum-based consensus algorithm using Raft. This will ensure that all nodes agree on the state of the inventory before any changes are persisted."
Which of the following statements BEST summarizes the core benefit of using a quorum-based consensus algorithm in this scenario?
Quorum-based consensus (like Raft) prioritizes reliability and consistency. It achieves this by requiring a majority of nodes to agree on an update before it's committed, providing resilience against failures. The other options are not the primary benefit – immediate propagation is often slower than guaranteed consistency; simplification isn't inherent in the design; manual conflict resolution remains possible.
31 / 41
"Sarah: 'I'm seeing a lot of timeouts when processing transactions through the payment gateway. It seems like we're not consistently acknowledging requests to the consensus ledger before submitting them to the external payment processor.' What should we do?'
Acknowledging requests to the consensus ledger is crucial for reliable transaction processing. The system needs confirmation from the ledger that a request has been recorded before submitting it to the external processor – otherwise, the payment could be processed twice if the acknowledgement is lost.
32 / 41
Reviewer: "This commit introduces a new `consensus_update` function, but it doesn't handle potential conflicts. What's the best way to ensure data integrity when multiple services are simultaneously updating the same record?"
Which of the following approaches would be MOST appropriate?
Optimistic locking is a good strategy – it avoids blocking other operations. However, the question asks for the *most* appropriate, and a simple 'last-write-wins' approach is prone to data loss if updates happen very quickly. Ignoring conflicts isn't a robust solution; distributed locks are more complex but provide stronger guarantees against corruption.
33 / 41
"@alice I'm seeing significant latency when querying the user profile service. The logs show multiple requests to the consensus database for each profile update. What could be causing this?"
Alice replies: "Perhaps we should investigate if our current implementation is using a full read of the entire consensus state instead of just the changes."
Alice's suggestion highlights a critical inefficiency: reading the entire consensus state on *every* update. A more targeted approach—only retrieving the changes—significantly reduces the amount of data transferred and processed, directly addressing the latency issue.
34 / 41
The following API response is received after a request to update a user's address using a consensus service:
`{
"status": "error",
"message": "Conflict: Another update to this record has been made concurrently."
}`
What does this response primarily indicate about the system's architecture and data management?
This response strongly suggests the use of MVCC. MVCC allows multiple clients to read and update data concurrently without blocking each other – a conflict message arises when these updates try to modify the same record simultaneously. The other options are less likely based on the error message.
35 / 41
Subject: Improve data consistency in inventory microservice.
Details:
"We've identified a situation where updates to inventory levels are sometimes lost due to race conditions. To mitigate this, we're implementing a quorum-based consensus algorithm using Raft. This will ensure that all nodes agree on the state of the inventory before any changes are persisted."
Which of the following statements BEST summarizes the core benefit of using a quorum-based consensus algorithm in this scenario?
Quorum-based consensus (like Raft) prioritizes reliability and consistency. It achieves this by requiring a majority of nodes to agree on an update before it's committed, providing resilience against failures. The other options are not the primary benefit – immediate propagation is often slower than guaranteed consistency; simplification isn't inherent in the design; manual conflict resolution remains possible.
36 / 41
"Sarah: 'I'm seeing a lot of timeouts when processing transactions through the payment gateway. It seems like we're not consistently acknowledging requests to the consensus ledger before submitting them to the external payment processor.' What should we do?'
Acknowledging requests to the consensus ledger is crucial for reliable transaction processing. The system needs confirmation from the ledger that a request has been recorded before submitting it to the external processor – otherwise, the payment could be processed twice if the acknowledgement is lost.
37 / 41
Reviewer: "This commit introduces a new `consensus_update` function, but it doesn't handle potential conflicts. What's the best way to ensure data integrity when multiple services are simultaneously updating the same record?"
Which of the following approaches would be MOST appropriate?
Optimistic locking is a good strategy – it avoids blocking other operations. However, the question asks for the *most* appropriate, and a simple 'last-write-wins' approach is prone to data loss if updates happen very quickly. Ignoring conflicts isn't a robust solution; distributed locks are more complex but provide stronger guarantees against corruption.
38 / 41
"@alice I'm seeing significant latency when querying the user profile service. The logs show multiple requests to the consensus database for each profile update. What could be causing this?"
Alice replies: "Perhaps we should investigate if our current implementation is using a full read of the entire consensus state instead of just the changes."
Alice's suggestion highlights a critical inefficiency: reading the entire consensus state on *every* update. A more targeted approach—only retrieving the changes—significantly reduces the amount of data transferred and processed, directly addressing the latency issue.
39 / 41
The following API response is received after a request to update a user's address using a consensus service:
`{
"status": "error",
"message": "Conflict: Another update to this record has been made concurrently."
}`
What does this response primarily indicate about the system's architecture and data management?
This response strongly suggests the use of MVCC. MVCC allows multiple clients to read and update data concurrently without blocking each other – a conflict message arises when these updates try to modify the same record simultaneously. The other options are less likely based on the error message.
40 / 41
Subject: Improve data consistency in inventory microservice.
Details:
"We've identified a situation where updates to inventory levels are sometimes lost due to race conditions. To mitigate this, we're implementing a quorum-based consensus algorithm using Raft. This will ensure that all nodes agree on the state of the inventory before any changes are persisted."
Which of the following statements BEST summarizes the core benefit of using a quorum-based consensus algorithm in this scenario?
Quorum-based consensus (like Raft) prioritizes reliability and consistency. It achieves this by requiring a majority of nodes to agree on an update before it's committed, providing resilience against failures. The other options are not the primary benefit – immediate propagation is often slower than guaranteed consistency; simplification isn't inherent in the design; manual conflict resolution remains possible.
41 / 41
"Sarah: 'I'm seeing a lot of timeouts when processing transactions through the payment gateway. It seems like we're not consistently acknowledging requests to the consensus ledger before submitting them to the external payment processor.' What should we do?'
Acknowledging requests to the consensus ledger is crucial for reliable transaction processing. The system needs confirmation from the ledger that a request has been recorded before submitting it to the external processor – otherwise, the payment could be processed twice if the acknowledgement is lost.
Frequently Asked Questions
What does the "Practical Consensus Vocabulary" exercise cover?
Practice practical consensus vocabulary: quorum fault tolerance, fencing tokens, lease expiry, and etcd/Zookeeper/Consul usage in production systems.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free to use with no account, sign-up, or paywall.
How many questions are in "Practical Consensus Vocabulary"?
This exercise has 41 questions. Each one gives instant feedback with an explanation, so you can see exactly why an answer is right or wrong.
Do I need to create an account to save my progress?
No account is required. The progress bar and score are tracked in your browser for the current session -- the exercise is designed to be a quick, repeatable drill rather than something you resume later.
What happens if I get an answer wrong?
You'll see the correct answer highlighted immediately, along with a short explanation of why it's correct. Wrong answers aren't penalized beyond your score, and you can keep going through every question.
How is this exercise different from reading an article?
Articles explain vocabulary and concepts through prose, while exercises like this one are interactive drills -- multiple-choice questions -- that test and reinforce your recall of specific terms and phrasing.
Can I retry this exercise?
Yes -- use the "Try again" button on the results screen to reset your score and go through all the questions again from the start.
Where can I find more Distributed Systems Consensus exercises?
Browse the full Distributed Systems Consensus hub for related drills, or check the site-wide exercises index for other IT English topics.
Is this exercise suitable for beginners?
This exercise assumes basic familiarity with IT terminology. If a term feels unfamiliar, check the site Glossary for a plain-English definition before attempting the questions.
How often is new content like this published?
New exercises are added regularly across all categories, alongside new vocabulary sets and articles. Check back on the exercises hub to see what's new.