Time in M — what people actually mean when they say it
Most teams don't have a productivity problem. They have a tracking problem. The methodology I'm going to walk through here is one I stumbled into three years ago while trying to cut down the amount of time our sprint retrospectives took. We were spending forty minutes on them and getting nothing useful back. Someone pointed out that we tracked hours but never tracked the actual time spent in a meeting, so the retros were always running long. That's when I started using the Time In M framework, and it's been my default ever since. Time In M stands for Time in Minutes. It sounds almost too simple, which is why most people skip past it and then wonder why their process improvement data is garbage. The core idea is that you stop logging work in hours or story points and you log it in minutes, every time, across every phase of the project. That means the planning phase, the execution phase, the review phase, and the handoff phase all get measured the same way. When everything uses the same unit, you can actually compare them against each other.
The Time In M Unlocking Efficiency Precision And Productivity Across Industries
I first ran into this concept at a manufacturing consultancy and they had it written on a whiteboard in the conference room. They weren't talking about software. They were talking about how long it took a line worker to complete a specific assembly step, from the moment they picked up the part to the moment they set it down. The same principle applies to knowledge work. It just feels more abstract because knowledge work doesn't have a visible stop button like a physical assembly line does. The way I use it now is straightforward. Before any task starts, I estimate the time in minutes. Not hours. Minutes. So instead of saying "this feature will take two days," I say "this feature will take about 480 minutes." Then when the task is done, I record the actual time in minutes. That's it. You do this for every single task, no exceptions. After about two weeks of this, you have a dataset that looks like this: planning took 90 minutes, design took 340 minutes, implementation took 1,200 minutes, testing took 450 minutes, handoff took 60 minutes. The total is 2,140 minutes for that feature, and you know exactly where the time went. What's interesting is that the numbers almost never match the original estimates, and that's not a failure. That's the point. The gap between estimated time in minutes and actual time in minutes is where your process problems live. If you consistently underestimate implementation by 40 percent but overestimate testing by 60 percent, you know you need to reallocate resources toward testing, not toward coding faster. That kind of insight doesn't come from hourly billing or story points, because those units are too coarse to catch the pattern.
One thing I learned the hard way is that you shouldn't measure time in M for tasks that are shorter than five minutes. The overhead of logging and recalling what you were doing within a five-minute window introduces noise that swamps the signal. I used to track every small email reply and internal chat exchange, and after a month of that I deleted the whole dataset because it was too unreliable to draw conclusions from. So I set a hard rule: if the task is under five minutes, you don't log it separately. You bundle it into the next larger task. This keeps the data clean without losing the information entirely. Another common mistake is to use time in M as a performance metric against individual people. That approach breaks the system within a month because people start gaming the numbers. They either pad their estimates to look safe or they rush through tasks and underreport the time. I stopped doing this after my team started deliberately breaking large tasks into smaller ones just to make the minute counts look better. The numbers improved, the actual work didn't change, and we wasted two weeks investigating a productivity increase that didn't exist. Once I switched to tracking time in M at the team level only, not the individual level, the gaming stopped and the data became useful again.
Get the Full Details
How to set this up in your own workflow
You don't need special software for this. I've run it successfully with a simple spreadsheet, a Trello board with custom fields, and even a dedicated time-tracking app called Harvest. The tool doesn't matter. What matters is that every task has three numbers attached to it: estimated minutes, actual minutes, and the phase category. The phase category is important because it lets you do cross-functional analysis later. You want to know whether your design phase is consistently bleeding into implementation, for example, and minute-level granularity makes that visible. Here's the actual spreadsheet structure I use. Column A is the task name. Column B is the estimated minutes. Column C is the actual minutes. Column D is the phase. Column E is the variance, which is just actual minus estimated. Column F is the phase total, which pulls in all the tasks for that phase and sums them up. You can build this in Google Sheets or Excel in about ten minutes. There's no reason to buy anything fancy for this. What usually takes people longer than expected is the initial habit of logging every single task. The first week feels tedious, and I won't pretend otherwise. I recommend starting with just one project team as a pilot, not rolling it out across the entire organization. When I tried to implement this company-wide at my last job, half the teams abandoned it within two weeks because they couldn't see the immediate benefit. The pilot team stuck with it for six weeks and by week seven the rest of the company was asking to join. That's the pattern that keeps showing up.
There's also a quirk with time in M that beginners miss. When you first start tracking in minutes, your numbers will look wildly inflated compared to what you're used to. A task you previously logged as "four hours" becomes "240 minutes," and that feels like a lot more data to manage. It's not. It takes the same amount of effort either way. The only difference is the unit. People get hung up on this transition for about a week and then it stops feeling unusual. If you're still resisting after seven days, you're probably overthinking it.
Where Time In M falls apart
I want to be clear about the cases where this doesn't work, because the people selling it as a universal solution aren't being honest. Time In M is useless for creative work that doesn't have a clear output boundary. A marketing campaign, a brand refresh, a design system overhaul — these projects have phases, but the boundaries between them are fuzzy, and trying to pin them down to exact minute counts produces data that looks precise but isn't actually accurate. In these cases, hourly tracking or milestone-based tracking tends to be more reliable. Another area where time in M struggles is with async-heavy teams spread across many time zones. If your team has members working in Tokyo, Berlin, and San Francisco, the coordination overhead becomes a significant part of the work that's difficult to attribute to any single task. I've found that in these situations, tracking time in M at the task level creates a lot of noise from handoffs and waiting periods. The solution is to add a fourth column for coordination overhead and log those minutes separately, so they don't get mixed into the actual work time. For small teams under fifteen people, the administrative burden of maintaining minute-level logs for every task can actually reduce productivity rather than improve it. The time spent logging cancels out most of the gains from better planning. I've seen this happen twice, and both times the teams went back to story points or rough hourly estimates and were happier. Time In M works best for teams of twenty or more, where the data aggregation across many tasks produces patterns worth acting on. Below that size, the signal-to-noise ratio isn't there yet.
If your organization already uses agile methodologies with sprint planning and velocity tracking, switching to time in M doesn't replace that system. It augments it. I still run two-week sprints and use story points for capacity planning. The minute-level tracking happens at the individual task level within each sprint. This dual-layer approach gives you both the high-level overview you need for planning and the granular detail you need for process improvement. Removing either layer makes the remaining one less useful. The takeaway is that Time In M is a tool, not a philosophy. It's useful for measuring and improving specific processes, but it's not a replacement for good project management, clear communication, or competent leadership. No amount of minute-level tracking will fix a team that doesn't know what it's supposed to be building. I learned that the hard way when I applied this framework to a project where the requirements kept changing every three days. The data was beautifully accurate and completely useless because the baseline kept shifting. Sometimes the problem isn't the measurement. It's the work itself.
