What if we added three engineers?
Every capacity question turns into an hours-long spreadsheet that's stale by the time you share it. Scheduling people, skills, and dependencies isn't a problem you can solve in your head.
Plenar is a planning engine that computes who does what and when, so you answer "what if we added three engineers?" in seconds, instead of an afternoon in a spreadsheet.
You’re in a roadmap review and an exec asks the obvious question: “If we pull two more engineers onto this, can we still hit the March milestone?”
You know the honest answer is “let me get back to you.” So you say that. After the meeting you open a spreadsheet, re-key who’s working on what, guess at who could pick up the unblocked tasks, remember that one of them is out the week of the 17th, and an hour later you have a number you only half-believe. By the time you hit send, someone has finished a task early and the number you just gave is already out of date.
This happens every time. New hire, a slip, a scope cut, a reprioritization. Every “what if” triggers the same manual re-derivation. And the frustrating part is that the question is completely reasonable. It’s the most important question a team lead answers all week.
Why you can’t answer it in the room
It’s tempting to read the hours-long spreadsheet exercise as a personal failing: if you were just more on top of things, you’d know the answer cold. You wouldn’t.
It’s structural, and there are two reasons. The first is that your planning tool doesn’t have a model of your team and your work. It has a list. It knows the tickets exist and roughly what order they’re in. It does not know who has the skills for each one, who is actually available next week, what each task is waiting on, or how those things interact.
The second is that even with a perfect model in front of you, you couldn’t do the math in your head. Fitting a dozen tasks to six people, each with different skills, different availability, and a web of dependencies, is a combinatorial problem: every assignment changes what’s possible for the next one, and the number of valid arrangements explodes far past anything working memory can hold. It’s the exact kind of problem people are bad at and computers are good at. Doing it by hand isn’t slow work; it’s a search that doesn’t fit in your head. So you do the only thing you can: push it to a spreadsheet and grind through a single arrangement, which is why the honest answer is always “let me get back to you.”
Backlogs sort. They don’t simulate.
Jira, Linear, Asana, a spreadsheet: all good at capturing work and ordering it by priority. None of them computes a schedule. They can tell you what’s near the top of the list. They cannot answer the question that actually matters: given these people, these skills, these dependencies, and this deadline — when does it land, how do we get there, and what would we have to give up to hit the date? And if they can’t answer that even once, they certainly can’t tell you what happens to the answer when you change one of the inputs.
So “what if we added three engineers” isn’t a query you can run. It’s a project you have to do. And because it’s expensive, you rarely do it at all. So the date you’re steering toward was never actually computed in the first place. It was a confident-sounding guess, made under assumptions that were shaky the day you made them and have only drifted since. You’re not steering by a stale calculation. You’re steering by a rotting hope.
A plan is a function of its constraints: people, skills, availability, dependencies, deadlines. If those are data, then “what if we change one” is a recomputation, not a meeting.
That single shift, from a plan you maintain by hand to one you compute from constraints, is what turns “let me get back to you” into an answer you give in the room.
What it looks like when the plan is computed
This is the bet behind Plenar. The inputs that actually decide when work lands are data, not notes in a doc: your team’s skills, weekly capacity, and time off; the dependencies between tasks; the current state of the work; and estimates grounded in how long similar work has actually taken for your team, drawn from the signals Plenar captures as you ship. From those, Plenar assigns the work and computes the schedule (who does what, in what order, finishing when) instead of asking you to lay it out by hand.
Which means a what-if is just a change to an input:
- “Add two engineers.” Add them with their skills, recompute. The projected ship date moves from Jun 25 to Jun 12; two goals flip from At Risk back to On Track; you can see exactly which tasks the new people picked up and which ones they couldn’t, because nobody on the team has the skill they need.
- “Cut to the must-haves.” Drop the Nice work, keep the committed Must work, recompute. Now you can see whether the deadline was a scope problem or a capacity problem.
- “Marcus Johnson is out the week of the 17th.” Add the time off (or let Plenar pull it straight from his connected Google Calendar), then recompute. The milestone slips three days, and you find out now instead of on the 16th.
Every one of those is seconds, not an afternoon. And because each one recomputes the whole plan against the same constraints that govern your plan of record, you’re not eyeballing a guess. You’re reading the same kind of plan you’d have committed to anyway, with one thing changed. Estimates carry their uncertainty through as a range (a most-likely and a pessimistic figure), so the answer tells you how much slack the date actually has, not just a single hopeful number.
A compass, not a crystal ball
Plenar doesn’t promise the one true plan for a future that hasn’t happened; nothing can. What it computes is the best plan available given everything known today: the optimal assignment and sequence for the constraints you actually have. Log a new one (a hire, a slip, a scope cut) and a new best plan falls out in seconds.
That’s the difference between a map you drew once (or never drew at all) and an instrument that keeps pointing true. Most teams navigate a whole quarter on a heading they set weeks ago and never re-check, flying blind, hoping the deadline is still where they left it. Plenar is the compass that re-points the instant the ground shifts. It can’t see over the horizon. But it always shows you the best heading from where you actually stand, and that heading is the same computation that governs your Plan of Record, not a hopeful number in a side spreadsheet.
Why it’s worth caring about
“Let me get back to you” is expensive in a way that doesn’t show up on any dashboard. It’s the hire you delayed because you couldn’t size the impact fast enough. It’s the deadline you committed to without checking, because checking was an hours-long job. It’s the scope cut you made by gut because modeling it properly wasn’t worth the afternoon.
When the plan is a model you can query, those decisions get cheap. You ask the question, you get the answer, you move. The teams that pull ahead in the next few years won’t be the ones with the most people. They’ll be the ones who can re-plan as fast as the situation changes.
Plenar computes your schedule from your team’s skills, availability, and dependencies, so “what if” is a button, not a meeting. See how the schedule is computed →