Depend On or Depend To? A Dev's Preposition Cheat Sheet

You write code that handles null tenants, race conditions, and distributed locks without breaking a sweat. Then you type “this fix depend to the cache layer” in a pull request and a tiny two-letter word betrays you.

Prepositions - those small connecting words like in, on, at, to, and for - cause more professional-English mistakes than almost anything else. Not because they are hard to understand, but because there is rarely a logical rule. You don’t reason your way to the right one. You either know the pairing or you guess.

This article hands you the pairings, so you stop guessing.

Why this matters

Your commit messages, PR titles, and standup updates are read by people who decide whether you write clearly. A wrong preposition rarely blocks understanding, but it quietly signals “still learning the language” on every line.

The good news: prepositions follow a small set of patterns plus a short list of fixed pairs. Learn maybe fifteen of them and you cover the vast majority of what you write at work all day. This is one of the highest-return things you can fix in your English, because the same handful of phrases show up in nearly every message you send.

The 30-second mental model

Two ideas carry most of the weight.

1. Time and place follow a “zoom” rule - big to small.

• in = big container or inside something: in June, in the repo, in production
• on = a surface, a day, or a list: on Monday, on the branch, on line 42
• at = an exact point: at 9am, at the endpoint, at line 42

Think of zooming a map. You start zoomed out (in the country), zoom to a street (on the street), then drop a pin on one address (at the building).

2. Most dev phrases are fixed pairings you memorize, not solve.

depend on, based on, responsible for, interested in - these are collocations, meaning words that habitually travel together. Native speakers didn’t reason these out either. They just heard them ten thousand times. You will treat each one as a single chunk: never depend, always depend on.

Why this trips you up

In your first language, one preposition often does the job of several English ones. So you translate word-for-word and land on “depend to” or “responsible of.”

You also mix the zoom levels - writing “on the repo” when a repo is a container, so it’s “in the repo.”

The fix is not grammar logic. It’s pairing the verb and its preposition together as one unit and reusing that unit until it feels automatic.

Direction vs. location: the to / in / on split

This one trips up developers constantly, because we move code around all day.

• Moving something somewhere → to. You push to a remote, deploy to production, reply to a thread, connect to a database, migrate to Postgres.
• Being inside a container → in. The file is in the repo. The bug shows up in production.
• On a surface or a list → on. You’re on the dev branch, a service listens on a port, you comment on a PR.

Watch all three appear in one real sentence:

The error happens in production at the checkout endpoint on the release branch.

Notice each zoom level gets its own word: the big container (in production), the exact point (at the endpoint), the surface or list item (on the branch). Once you see that pattern, sentences like this assemble themselves.

The collocations you’ll actually use

Here is the short list that covers most of your work writing. Memorize the pairing, not a reason.

Phrase	Use	Example
depend on	a dependency	The job depends on Redis.
based on	a basis	Pricing is based on quantity.
responsible for	ownership	I’m responsible for the queue worker.
good at	a skill	She’s good at writing tests.
interested in	an interest	I’m interested in the caching task.
listen on	a port	The service listens on port 8000.
deploy to	an environment	We deploy to staging first.
push to	a remote	Push to origin.
merge into / to	a target	Merge into main.
work on	a task	I’m working on the bug.
comment on	a thing	Please comment on the PR.
reply to	a message	Reply to the review thread.
connect to	a service	Connect to the database.
migrate to	a target	Migrate to PostgreSQL.
consist of	parts	The pipeline consists of three stages.

A quick mnemonic to glue it together: Moving somewhere → to. Sitting inside → in. On a surface or a list → on.

Common misconceptions

“Based off” is fine in writing.” It isn’t. In casual speech “based off” and “based off of” are everywhere, but professional writing wants based on. Always.

“I can reason out the right preposition from the meaning.” Usually you can’t. Why is it “good at” a skill but “interested in” a topic? No satisfying reason exists. These are habits of the language, not logic puzzles. Stop trying to derive them and just store the pairs.

“Merge to and merge into mean different things.” They’re close to interchangeable, with “merge into” being slightly more precise. Don’t agonize over it; pick “into” and move on.

“On the repo” and “in the repo” are both okay.” A repository is a container, so you’re in it. A branch is more like a line you’re standing on, so you’re on it. The file lives in the repo, on branch dev.

How to use this

1. Pick your top five offenders. For most developers that’s depend on, based on, deploy to, responsible for, and comment on. Master these first.
2. Store each as a chunk, never as a single word. Don’t memorize “depend.” Memorize “depend on.” Say the preposition in the same breath.
3. Apply the zoom rule to time and place. Big container → in, surface or day → on, exact point → at. Build the sentence from wide to narrow.
4. For movement, default to to. Push, deploy, reply, connect, migrate - if something travels toward a destination, reach for to first.
5. Proofread your PR titles and commits specifically for prepositions. They’re short and public, so a single fix there has outsized payoff.
6. Keep the table above pinned. When in doubt, check it for two seconds instead of guessing. Real speakers also just looked these up once and remembered.

A few patterns in the wild:

• Commit: “Fix crash that depends on a null tenant” - not “depend to.”
• PR title: “Deploy worker to staging” and “Merge feature into main.”
• Standup: “Today I’m working on the cache ticket and will comment on Pravin’s PR” - not “working in” or “comment in.”
• Code comment: // Service listens on port 4000 - not “listens in port.”

Practice: fix the preposition

Correct the preposition (and any spelling or capitalization slips you spot). Answers follow.

1. the build depend to a env variable that is not set
2. i am interested on picking up the payment ticket
3. we deploy in production every friday
4. the price calculation is based of the product size
5. who is responsible of the queue worker
6. our api listen in port 8000 by default
7. she is really good in writing clean tests
8. The config file is (A) on / (B) in the repo, and (A) on / (B) in the dev branch.

Answers:

1. The build depends on an env variable that is not set.
2. I’m interested in picking up the payment ticket.
3. We deploy to production every Friday.
4. The price calculation is based on the product size.
5. Who is responsible for the queue worker?
6. Our API listens on port 8000 by default.
7. She is really good at writing clean tests.
8. (B) in the repo, (A) on the dev branch - you’re inside the container but on the branch.

Conclusion

The single takeaway: prepositions are pairs you memorize, not rules you solve. Lock in fifteen collocations and the zoom rule for time and place, and you’ve fixed the mistake that trips up developers more than any other.

Here’s the thing those pairings hint at, though. “Depend on,” “based on,” “responsible for” - once you start treating English as chunks rather than individual words, a lot more than prepositions clicks into place. Articles (a, an, the) work the same way, and they’re the next small word quietly shaping how your writing reads. Worth a look next.