5 exercises distinguishing commonly confused IT verbs — knowing which one to use shows professional precision.
Key verb distinctions
merge (preserves history) vs rebase (rewrites history)
refactor (same behaviour, cleaner code) vs rewrite (start over)
debug (code-level investigation) vs troubleshoot (system-level diagnosis)
scale out (more instances) vs scale up (bigger instance)
deploy (to a target) vs release (versioned delivery) vs ship (to users)
0 / 5 completed
1 / 5
A developer says: "We need to ___ the feature branch into main — all approvals are in and CI is green."
Choose the correct verb. Note: the team keeps a linear history and squashes commits.
"Merge" vs "rebase" — understanding the key difference:
Both merge and rebase integrate changes from one branch into another, but they do it very differently:
Merge:
Combines two branch histories into one with a merge commit
"Merge the feature branch into main" → creates a merge commit on main
Preserves the exact history of both branches
Results in a branching/non-linear history
Rebase:
Replays commits from one branch on top of another
"Rebase the feature branch onto main" → rewrites feature commits so they appear after main's latest commit
Creates a cleaner, linear history
Rewrites commit hashes — never rebase shared branches
Key phrase distinction: You merge into a target branch. You rebase onto a base branch. "Merge into main" and "rebase onto main" are both correct; "rebase into main" is unusual phrasing.
2 / 5
A senior developer says: "Before adding this new feature, we need to ___ the payment module. The class has become a 2,000-line God Object and it's untestable."
Which verb is correct?
"Refactor" vs "rewrite" — a critical engineering distinction:
Refactor:
Restructure existing code without changing its external behaviour
Goal: improve readability, maintainability, and testability
Example: extract a large class into smaller ones, rename variables for clarity, remove duplication
Incremental: done in small, safe steps with tests at each step
"Refactor the payment module" → clean it up, split it, but it still does the same thing
Rewrite:
Start over from scratch, replacing the existing implementation entirely
Higher risk: you lose the battle-tested behaviour of the original
"Rewrite in TypeScript" / "complete rewrite from scratch"
Joel Spolsky famously wrote: "Never rewrite from scratch" — it's almost always a mistake
When to say which: "We're refactoring the service to be more testable" (incremental improvement). "We're rewriting the frontend in React" (full replacement). The question's context (untestable, God Object) calls for refactoring — not a full rewrite.
3 / 5
A team is discussing a production incident. The tech lead asks: "Can someone ___ this issue? We need to know whether it's a code bug, a configuration problem, or a data issue."
Which verb is correct?
"Troubleshoot" vs "debug" — similar but with different scopes:
Troubleshoot:
Systematically investigate and diagnose a problem across a system
The cause is unknown — it could be code, config, network, data, environment, or user error
"Troubleshoot the issue" → investigate broadly to identify the category of problem
Used in DevOps, SRE, support, and incident response contexts
Also used as a noun: "troubleshooting guide", "let's do some troubleshooting"
Debug:
Find and fix bugs in code specifically
You already know it's a code problem — you're locating the exact defect
"Debug the authentication module" → step through the code to find the bug
The question's context: The cause is unknown (code? config? data?) — so "troubleshoot" is correct. You troubleshoot before you debug: troubleshoot to identify the problem category, then debug the specific code if it turns out to be a code bug.
4 / 5
A DevOps engineer says: "The API service is struggling under load. We need to ___ — add more instances and put a load balancer in front."
Which verb is correct?
"Scale" — the standard verb for increasing system capacity:
Scale is the technical term for increasing a system's capacity to handle more load. The description in the question (add more instances, load balancer) describes horizontal scaling specifically.
Scaling vocabulary:
scale (general) → increase capacity
scale up (vertical scaling) → make a single instance larger: more CPU, more RAM: "Scale up the database server"
scale out (horizontal scaling) → add more instances: "Scale out the API tier behind a load balancer"
auto-scale → automatically adjust capacity based on load
scale to zero → serverless pattern: no instances when idle
Why not "resize"? "Resize" refers to changing the size of one thing (resize a VM, resize a disk). It doesn't imply adding multiple instances. "Scale" encompasses both adding instances and changing instance sizes, and is the correct term in distributed systems contexts.
5 / 5
In a team retrospective, a developer says: "We spent three days trying to ___ the checkout flow before realising the problem was a typo in a config file."
Which verb is most natural here?
"Debug" — the most natural verb for the act of hunting a bug in code:
Debug literally means to remove bugs (defects) from code. It describes the process of actively investigating, stepping through, and correcting code. In the context of "we spent three days trying to X the checkout flow," "debug" is the most natural because it captures the investigative, iterative process they went through.
Debug vs Fix vs Troubleshoot:
debug → the investigative process of finding the bug in code (can take time, involves observation)
fix → the act of correcting it (comes after debugging); "debug for three days, then fix in 5 minutes"
troubleshoot → broader systems investigation (before you know it's a code bug)
Debug collocations:
debug a function / a component / a flow → investigate for bugs
step through the code → use a debugger to execute line by line
set a breakpoint → pause execution at a specific line for inspection
inspect the variables → check their values during execution