time blocking
Time Blocking for Software Developers: A Practical Setup
Developers lose time to interruptions that arrive from every direction, so a generic schedule breaks by Tuesday. This guide shows a block layout built around build time, a reactive window and a handoff note.
A developer's day is not one long stretch of coding. It is code, a review request, a question in chat, a meeting, a build that fails, and a half-remembered idea about the thing you were doing an hour ago. Time blocking helps because it gives each of those a place, and it protects a few long stretches for the work that needs the most thinking. This guide gives you a layout built for that kind of day: two build blocks, one reactive window, fixed meeting slots, and a handoff note before every switch.
If you want the general method first, the complete guide to time blocking covers it. This page is about what changes when your work is code.
Why developers need a different layout
Most time blocking advice assumes you control your calendar. Developers often control less of it than they would like, and the work itself is sensitive to being broken up. Two bodies of research are worth knowing, and both come with limits.
The first is Gloria Mark's field study of interruptions at work. In a Gallup interview about the study, she says we shadowed 36 managers, financial analysts, software developers, engineers, and project leaders for three days. Two findings matter for a block schedule. First, analysts and developers are involved with a smaller network of people, so they have fewer external interruptions. Second, and less comfortable, people interrupted themselves almost as much as they were interrupted by external sources.
That second point changes the plan. A calendar can keep other people out of a block. It cannot stop you from opening a browser tab. A good developer layout therefore needs a place to put your own "I should check that" impulses, which is what the reactive window below is for.
Mark also reports that most interrupted work did get picked up again: it was resumed, on average, in 23 minutes and 15 seconds. That number covers knowledge workers in general and includes time spent on other tasks in between, so it is not 23 minutes of lost coding. It does show that returning to a task is not instant.
The second source is a survey of programmers. Researchers conducted a survey with 141 software developers to investigate their perceptions of differences between task switching and task interruption. They report that practitioners perceive considerable similarities between the disruptiveness of task switching (either planned or unplanned) and random interruptions. This is a survey of perceptions, not a measurement of lost hours, so treat it as what developers say about their own work. Still, it supports a useful rule: a switch you chose still costs something. Planning your switches does not make them free, but it does let you make fewer of them.
The five block types
Developers do not need dozens of categories. Five cover most days.
| Block | What goes in it | Typical length | Notifications |
|---|---|---|---|
| Build | New code, design, debugging a hard problem | 90 to 150 minutes | Off |
| Review and respond | Pull request reviews, chat, email, ticket triage | 30 to 45 minutes | On |
| Meetings | Stand-up, planning, one-to-ones | Fixed slots | As needed |
| Maintain | Dependency updates, small fixes, documentation, tidying tickets | 45 to 60 minutes | Off |
| Buffer | Overruns, surprises, a walk | 15 to 30 minutes | Your choice |
Notice what is missing: a block for "coding all day". Build blocks are the ones you protect hardest, and there are only one or two of them. Two good blocks are worth more than a day of fragments.
Build blocks
A build block is for work where you hold a lot of context at once: a feature that touches several modules, a bug whose cause you do not yet know, a design you are still shaping. Put these first in your day if your team's meetings allow it, and give each one a single named target such as "finish the retry logic for the export job". A block called "coding" invites drift. A block with a target tells you when it is done.
Length is up to you. Try 90 minutes to start: long enough to get into a problem, short enough to schedule around. For shorter sessions, see focus sessions that stick.
The reactive window
This is the block that makes the rest work. Two or three times a day, you set aside a short stretch where you answer chat, review pull requests, and look at your inbox. Outside that window, those things wait.
The reason is attention, not manners. Sophie Leroy, a University of Washington Bothell researcher who studies this, describes how unfinished tasks stay active in our minds, disrupting performance throughout the day. To limit it, the same article says Leroy suggests working offline to avoid interruptions and taking breaks between tasks and before meetings. A reactive window is a scheduled version of that advice: the checking still happens, but at a time that does not cut a build block in half.
Tell your team the window exists. A status line such as "Heads down until 11:30, back in chat then" helps. For anything truly urgent, agree on one way to reach you, such as a phone call.
Meeting slots
Meetings are the one category you often cannot move, so the goal is to keep them from scattering across the day. In the same survey of 141 developers, 64 (45%) stated that switching to daily meetings has a negative or very negative impact on their performance after resuming the primary task. The paper adds that respondents who perceived that switching to daily meetings negatively impact their performance on the primary task are working in a company without any pre-defined schedule for daily meetings.
That is a pattern in survey answers, not proof. It does suggest a cheap experiment: ask for recurring meetings to sit next to each other or at the edges of the day, so build blocks get the middle.
Maintain and buffer blocks
Maintain blocks hold the small jobs that never feel urgent: updating a dependency, writing a missing README section, closing stale tickets. Buffer blocks are empty on purpose. When a build block runs over, the overrun lands in the buffer instead of pushing a meeting or the end of your day.
A sample day you can copy
This is a template, not a rule. Shift it around your team's fixed commitments.
| Time | Block | Target |
|---|---|---|
| 9:00 to 9:30 | Review and respond | Clear overnight messages, pick the day's build target |
| 9:30 to 11:30 | Build | One named piece of work |
| 11:30 to 11:45 | Buffer | Overrun, stretch, water |
| 11:45 to 12:15 | Review and respond | Pull requests and replies |
| 12:15 to 13:15 | Lunch | Away from the screen |
| 13:15 to 13:45 | Meetings | Stand-up and any recurring sync |
| 13:45 to 15:30 | Build | Second target, or the continuation of the first |
| 15:30 to 16:15 | Maintain | Small fixes, documentation, tickets |
| 16:15 to 16:45 | Review and respond, then wrap-up | Reply, write the handoff note for tomorrow |
Both build blocks are at least ninety minutes, the reactive windows sit at the start, middle and end, and the last block ends with a note to your future self, described next.
The handoff note
The most developer-specific habit in this guide is also the smallest. Before you leave any task, whether for a meeting, lunch or the end of the day, write two or three lines: what you just did, what you were about to do next, and anything you were holding in your head that is not in the code.
This is a practical form of a method Leroy describes. In the same UW Magazine piece she says that taking even a few seconds to review what she just did or agreed to do next lets her brain relax and switch focus. That is one researcher's description of her own routine and not a controlled result for programmers, so use it as a habit to try rather than a guarantee.
A good handoff note has three parts:
- State. "Export job now retries three times; test for the timeout case is written but failing."
- Next step. "Next: check whether the mock clock is reset between tests."
- Loose thread. "Not sure the backoff constant belongs in config. Ask in review."
Keep the note where you will see it first when you return: a comment at the top of the file or a line in the ticket. Read it before you touch the keyboard.
What to do when the plan breaks
Plans break in developer work all the time. A production issue, a blocked deploy, a colleague who needs a quick answer. The point of a block schedule is not that it never breaks. It is that you know what you moved.
Triage rule. When something arrives during a build block, ask one question: does this need me in the next hour? If yes, take it, write a one-line handoff note for what you were doing, and move the displaced build block into the next open slot or the buffer. If no, put it in the reactive window and carry on.
Incident days. If an incident takes the afternoon, do not try to rescue the plan. Delete the blocks that cannot happen and write tomorrow's first build target before you finish.
Blocked on someone else. When a build block stalls while you wait for a review or an answer, switch on purpose to a maintain task and note the switch.
Sizing blocks honestly
New block schedules tend to fail the same way: the blocks are too optimistic. A feature you plan for two hours takes four. The fix is not to try harder. It is to measure.
For one week, write the planned length next to each build target and the actual time next to it when you finish. At the end of the week, look at the pairs. You may find a consistent gap on certain kinds of work, such as debugging or anything that touches a legacy module. Use that gap to size the next week's blocks, and say so in your plan: "Debugging, planned 2 hours, my usual is 3."
Your numbers are the ones that count. The comparison of time blocking and time boxing shows how to put a limit on a task inside a block, and time blocking vs task batching helps if your reactive tasks pile up.
Setting it up in your tools
You can run this on paper, in your calendar, or in a planner. A few notes on the options Xenith offers.
- Time Blocking Planner. The free Time Blocking Planner lets you add tasks, place them on a timeline or press "Fill my day", leave 15 minutes between blocks, and add the blocks to your calendar as an .ics file. It is a quick way to draft the sample day above.
- Focus Timer. The Focus Timer has presets that include 90 minutes, which matches a build block, and a session is logged when you finish it. Run it at the start of each build block so the length is visible.
For more layouts, the time blocking schedule templates article has ready-made days, and deep work vs shallow work explains the split behind the build and reactive blocks.
A one-week trial
Do not redesign your life. On Monday, place two build blocks and one reactive window, and name a target for each build block. From Tuesday to Thursday, keep the layout and write a handoff note before every meeting. On Friday, compare planned and actual lengths. The next Monday, change one thing only: a longer build block, a moved meeting, or a second reactive window.
Frequently Asked Questions
How many time blocks should a developer have per day?
Start with two build blocks, two or three short reactive windows, your fixed meetings, one maintain block and a buffer. That is about eight or nine blocks, most of them short. Add more only if a real task has no place to go.
How long should a coding block be?
Try 90 minutes for a first build block and adjust from there. Log the planned and actual length of a few targets, and size the next week's blocks from what you see.
What do I do when a teammate interrupts a build block?
Ask whether it needs you in the next hour. If it does, take it, write a one-line handoff note, and move the displaced block to the buffer or the next open slot. If it does not, say you will reply in your next reactive window.
Should I block time for meetings too?
Yes. Meetings you cannot move still belong on the plan so you can see what is left for build time. Where you have a say, group them at the edges of the day.
Does time blocking work on an on-call week?
It works as a draft that you expect to revise. Block the same layout, keep the buffer larger, and treat an incident as a reason to delete blocks, not as a failure of the plan.
Put it into practice in Xenith
Keep reading
Time Blocking: The Complete Guide to Scheduling Your Day
Time blocking gives each part of your day a named job before it starts. Here is how to build a schedule, one worked day, and how to adjust when the plan slips.
Time Blocking vs Time Boxing: Which to Use
Time blocking decides where work sits on your calendar, and time boxing decides how long a task may take. This guide compares them and shows how to block first, then box.
Time Blocking vs Task Batching: Which to Use
Time blocking assigns work to stretches of your calendar, and task batching groups similar tasks so you switch less. This guide compares them and shows a day that uses both.
Time Blocking Schedule Templates You Can Copy Today
A good time blocking template saves you the hardest part: the blank calendar. Here are four you can copy directly, and the adjustments that keep them from falling apart by Wednesday.
Deep Work vs Shallow Work: What the Difference Means for Your Productivity
Most knowledge workers spend 70%+ of their day on shallow work that creates busyness without meaningful output. Here's how to understand the distinction and shift the ratio.
Focus Sessions That Stick: The Complete 25-Minute Protocol
A deep guide to running 25-minute focus sessions that build momentum, reduce decision fatigue, and compound into real output over time.