Why the split breaks down in practice
Every company I've worked at has divided engineering time between product work and engineering work. The ratio moved around — sometimes 70% product and 30% engineering, sometimes an even 50/50 — with the aim of shipping features while still leaving room for technical debt, system upgrades, and documentation. Agreeing to that ratio is the easy part. Several failure modes show up once it's in motion:
- Product can end up in conflict, whether over the nature of the work or the time it consumes. That strains the relationship between the two groups, and if Product is caught by surprise, the boundaries around your engineering time can tighten.
- Engineers may not know what is expected of them. Running efforts in parallel is difficult, and a clear process is what fixes that.
- The maintenance path has to be explicit. A large system upgrade can affect other teams over time, and unclear long-term ownership will come back to bite you.
Communication, planning, and explicit expectations are what keep those problems from landing.

Writing the work down and getting Product on board
Once you've picked a problem to tackle, write a short one-sheeter for stakeholders covering what the work is, how long it should take, and why it matters. For a larger project, break it into GitHub/GitLab/Jira issues and label it by type so the existing project tooling shows the planned work and weekly expectations. Keep the conversation with Product partners open about scope and the nature of the work, so nothing lands as a surprise; how much that matters depends on the team and company culture. Engineers benefit from the same clarity — understanding the shape of the work makes the individual issues easier to take on.
Splitting every engineer's time across both kinds of projects is often worse for focus than dividing the work within the team instead: three people on product work for a few weeks and one on engineering work is a valid arrangement. Other jobs, migrations among them, may need everyone involved so institutional knowledge is shared evenly. Team size, the volume of product work, and the project type all change the calculus. When the right path isn't obvious, a group brainstorm helps — and align everyone on why the project matters while you're at it.
Technical debt
Technical debt is usually the most valuable engineering work available. Every slow feature is time lost on product development and, in salary terms, money lost on engineering effort. Some debt is normal, especially at smaller companies where speed is worth more than tidiness, but past a certain point it cripples development and releases and leaves the codebase unstable. Fixing it can be urgent or gradual.
Much of this emerges from the bottom up: the developers closest to the system know the day-to-day debt better than most EMs do. An EM's job is spotting the larger patterns — many people complaining about the same thing rather than one developer with a strong opinion. Before starting, poll the team on how much time they lose in a typical week versus what an alternative would buy them.
Refactor-heavy debt works best when everyone agrees in advance on which pull requests are needed. Updating CSS in a million places, or converting old class components to hooks, shouldn't arrive as one enormous PR — but splitting per component doesn't make sense either. Decide as a team how much each PR holds and what the review is expected to cover, or you'll create a review hole for the duration of the work.

Innovation projects
Hack week or innovation week projects, where developers build something product-adjacent without constraints, are generative — features on well-known applications have come out of them, and it's energizing for a team to see its own idea ship. Run inside the split engineering time, though, they can feel to Product like a slight. Product's job is to propose features, plan with stakeholders, build roadmaps from metrics and research, and get onto the engineering schedule through a project manager. Unplanned work can fork an existing plan, contradict research Product already has, or slow down a make-or-break feature.
This plays out well when the EM talks to Product up front and treats it as a partnership. If Product says a feature doesn't make sense, they likely have a reason, and listening to each other usually produces a path both sides agree on. Address their fears directly: if they worry product work will lose time, ask the team how many weeks it would take at half time, knowing estimates will shift once they dig in, and be explicit that nobody is expected to work at a break-neck pace. Small projects that run alongside regular work are ideal. Try something very small first to surface the bumps and to build Product's trust that you'll still deliver and won't go rogue.
Finally, settle who owns metrics and outcomes, including the failures. Product gets to set direction partly because they're on the hook when things go wrong. Be clear that as an engineering leader you're taking responsibility for outcomes, good and bad, to keep the relationship healthy.
Ongoing work: documentation and tooling
Internal documentation, tooling at companies without a dedicated tools team, and small maintenance tasks attract the least pushback of any engineering work. These differ from one-off projects: they're iterative, not something you ship once. Documentation, for example, should get time built into the feature process itself.
Say you've built a feature that lets teams collaborate, including a microservice other teams can use. Without internal docs explaining the expected parameters and how to extend it, nobody outside your team knows it exists. Documentation is the difference between the service getting adopted and your team being pulled into pairing sessions every time someone needs it — or worse, people hacking around it and making a mess of something that could have been quick and efficient.
Unlike innovation work, nobody craves slow ongoing tasks, so setting the process and expectations up front works best. Documentation is an often invisible but essential part of a functioning team: it helps onboarding, gets everyone aligned on system architecture, and can push developers to solidify what they built and how they're solving it.

Handling a migration
Migrations likely touch everyone, so they're organized differently from other projects. There's no single right approach, and the details vary by kind: framework to framework, breaking up a monolith, or moving to a different build process or server. The organizational options, at a high level:
- Research as much as possible up front. You can't know everything, but discovering something critical halfway through is what you're avoiding — and it's useful information to share with stakeholders.
- Timebox internal debates about direction and give the decision to one clear owner. Many technical problems have no single true solution, so one owner decides and everyone else disagrees and commits. Still give people room to say what gives them pause, even in disagreement — they may have thought of something you haven't.
- Document a migration plan at a high level, then work through the impact on each team. This is also the moment to explain the importance to Product: an aging codebase that can't work with current libraries and tools, or a new build process that would save engineering time on releases.
- Define maintenance and ownership ahead of time. If one team's build process migration creates problems for another, who fixes them to unblock that team? Decide before it happens.
- Plan for the all-hands phase. Some migrations can go slowly, team by team, or front-load most of the work. But there is usually a critical stretch when the whole team is needed, and unlike parallelizable work, feature work may have to stall while the new system goes in. Work with Product on the timing — seasonal customer lulls can be the breathing room you need. If they let engineering go to 100% for a while, return the favor: once the platform is stable, give 100% of team time back to product work.
Closing the loop with recognition
Recognition deserves the same weight as a launch. The team parallelized its efforts, acted as a strong partner to Product, and delivered something for the engineering organization as a whole — that deserves to be marked, not quietly filed away.
Signaling that you value this work matters because it is frequently thankless yet highly impactful. It also builds trust: engineers learn that taking on the hairy problems pays off in their own career path, not just in the backlog. The cost of celebrating with the team is minimal; the cultural payoff is not.



