For a long time, I treated notifications like a normal tax on working online.
Email arrived, I checked it. WhatsApp flashed, I looked. A social app put a red number on the screen, and some part of my brain wanted to clear it even if I had no reason to open the app.
I told myself I was staying reachable.
What I was actually doing was letting almost any application interrupt technical work whenever it wanted.
I did not understand how expensive that was until I turned most notifications off for a month.
The first thing that changed was not my mood. It was my coding.
Context switching was stealing more time than the message itself
A notification may take three seconds to read. That makes it look cheap.
The real cost is what happens around those three seconds.
If I am tracing a bug, I may be holding several pieces of state in my head at once: what the user clicked, what the frontend sent, what the API returned, what the database contained, and which condition should have handled the response.
A message interrupts that model.
When I return, I do not simply continue from the same mental position. I rebuild part of the model first.
Do that repeatedly and a one-hour debugging session becomes a collection of short fragments separated by tiny recoveries.
The work still gets done eventually, but it feels harder because I keep forcing my brain to reload it.
The first week felt strangely empty
When I disabled most notifications, I kept checking my phone anyway.
That was the part that surprised me. The device did not need to buzz. I had already learned to interrupt myself.
I would reach for it during a build, after an error, while waiting for a page to reload, or the moment a task became slightly uncomfortable.
That showed me the notification was only half the system. The other half was habit.
So I changed how I checked messages too. Instead of allowing every app to decide when I looked, I started checking at points I chose: after a focus block, between tasks, or when I was intentionally doing admin rather than development.
The difference sounds small. It changed the ownership of my attention.
I kept the channels that actually matter
I did not turn my phone into a brick.
Some communication really can be urgent. Calls from important people stay available. Messages that genuinely need fast responses can have exceptions. The goal was not disappearing.
The goal was separating urgency from software that merely wanted engagement.
Email does not need to interrupt a database migration. A social notification does not need to appear while I am reviewing authentication logic. Analytics do not need to announce themselves while I am writing a component.
Most online information can wait until I choose to look at it.
Deep work became less dramatic
Before the experiment, long concentration felt like something I had to manufacture. I needed the right mood, the right music, enough discipline, maybe a perfect two-hour block.
After removing interruptions, focus became more ordinary.
I could sit with a problem longer because fewer things were asking me to leave it.
That is an important distinction. Sometimes we try to improve concentration by adding tools when the real answer is subtraction.
No new productivity app can protect attention if ten other apps still have permission to break into it.
My code got calmer
This is difficult to measure perfectly, but I noticed a change in how I worked.
I was less likely to make several unrelated edits between tests. I read error messages more carefully. I spent more time reproducing a problem before searching for an answer. I finished one small path before opening another.
In other words, the code started reflecting the rhythm of the work.
Fragmented attention had been producing fragmented decisions.
Longer attention produced more deliberate ones.
I stopped treating fast replies as proof of reliability
One of the beliefs behind my notification habit was that reliable people reply quickly.
That sounds reasonable until “quickly” turns into “immediately.”
If every incoming message can reorder your current task, you are not only reachable. You are permanently interruptible.
I have found that reliability can mean something different: people know I will respond, but they do not necessarily get to choose the exact minute I stop what I am doing.
That boundary is especially important when you are building alone and every role already competes for the same person. Development, support, content, admin, planning, and marketing can all consume the same day if you let them arrive whenever they want.
My current notification rule
I now think about notifications in three groups.
Immediate: things where delay can genuinely matter. A small number of calls or messages belong here.
Scheduled: things I want to see, but at times I choose. Email, most messages, dashboards, and project updates usually belong here.
Unnecessary: things that do not improve my day enough to earn any interruption at all. Those stay off.
The categories are not universal. What matters is making the choice intentionally instead of accepting every app's default.
The phone is not the only source
Desktop notifications can be worse because they appear directly inside the work environment.
I disable browser prompts I do not need. I avoid keeping communication tabs open during difficult coding sessions. If a tool can send both email and browser notifications for the same event, I do not need both.
The principle is simple: one event should not be allowed to interrupt me through four different channels.
A month was long enough to change the baseline
The experiment did not turn me into someone who never checks his phone. I still get distracted sometimes. I still open things out of habit. I still have days where focus is poor for reasons no settings menu can fix.
But my baseline changed.
Constant interruption no longer feels normal.
That may be the most valuable result.
Once you experience a few hours of technical work where nothing is trying to pull you away every five minutes, the old way starts looking unnecessarily expensive.
The biggest lesson was not that notifications are bad. They are useful when the interruption is worth the cost.
The problem is giving every app permission to decide that for you.
My coding improved when I took that decision back.