These bugs won't trigger your error tracker. They'll quietly drain performance, reliability, and user trust until the damage is structural.

Your dashboard is green. Sentry is quiet. But somewhere in production, your app is getting slower. Memory creeps. API calls duplicate.

The UI stutters on interactions nobody tests. None of this throws. All of it costs you users. This is a catalog of the silent ones. Not beginner gotchas, the patterns experienced engineers ship, that cost real money, and that take months to surface.

1. Mutating Objects You Don't Own

JavaScript passes objects by reference. Modify an argument, and you're reaching back into the caller's scope. No error, just corrupted data upstream.

      
`// ❌ Mutates the original array, caller's data is now corrupted
function formatUsers(users) {
for (let i = 0; i < users.length; i++) {
users[i].name = users[i].name.trim().toLowerCase();
}
return users;
}`

`// ✅ Return new data, never touch the input
function formatUsers(users) {
return users.map(u => ({ ...u, name: u.name.trim().toLowerCase() }));
}`

    

The cost of a shallow copy is negligible. The cost of debugging a mutation chain across six functions is not

2. Swallowed Errors in Async Code

The community internalized "always wrap async code in try/catch" without the second half: and do something meaningful with the error.

      
`// ❌ Catches everything, handles nothing
try {
const res = await fetch('/api/user/sync');
const data = await res.json();
updateLocalState(data);
} catch (err) {
console.log('sync failed'); // that's it
}`

    

The sync silently fails, local state diverges from the server, and the real bug surfaces six calls later with zero traceability. An error you swallow today becomes a mystery you debug for a week next quarter.

3. Unbounded Event Listeners

Every addEventListener without cleanup is a leak. Open a modal 30 times and you have 30 stacked keydown handlers, all firing on every keystroke.

      
`// ❌ Called every time the modal opens, never cleaned up
function initModal() {
document.addEventListener('keydown', handleEscape);
window.addEventListener('resize', repositionModal);
}`

`// ✅ AbortController: one signal tears down everything
function initModal() {
const controller = new AbortController();
document.addEventListener('keydown', handleEscape, { signal: controller.signal });
window.addEventListener('resize', repositionModal, { signal: controller.signal });
return () => controller.abort();
}`

    

4. for...in on Arrays

for...in iterates enumerable properties, not indices. It works on arrays by coincidence and breaks the moment anything adds a property to the array or its prototype.

      
`const scores = [10, 20, 30];
scores.metadata = 'test';`

`for (const i in scores) console.log(i); // "0", "1", "2", "metadata"
for (const s of scores) console.log(s); // 10, 20, 30 ✅`

    

for...in is for objects. for...of is for iterables. Mixing them never throws — it just silently includes garbage.

5. Forgotten clearInterval

A single forgotten setInterval is a background process that runs forever. Call the function three times and you have three overlapping polling loops. Server load triples. No error anywhere.

      
`// ✅ Always return a cleanup mechanism
function startPolling(endpoint, callback) {
const controller = new AbortController();
const id = setInterval(async () => {
try {
const res = await fetch(endpoint, { signal: controller.signal });
if (res.ok) callback(await res.json());
} catch (err) {
if ([err.name](http://err.name/) === 'AbortError') return;
}
}, 5000);`

`return () => { clearInterval(id); controller.abort(); };
}`

    

Every timer must return a function that stops it. If your setup code doesn't produce cleanup code, you've written a resource leak.

The Common Thread

Every mistake here shares three properties: it doesn't throw (no tracker will catch it), it compounds (one instance is a quirk, a thousand is an unreliable product), and it's invisible until it's expensive (surfacing as churn and support tickets, not stack traces).

The defense isn't heroic debugging. It's structural prevention, strict linting, CI gates, review checklists, and a team culture where "it works" is the beginning of the quality conversation, not the end.