Run a pull-planning workshop that ends as a real schedule
You know the ritual: a wall of coloured stickies, the trade leads pulling backwards from a milestone, real arguments about who hands off to whom — and then it all ends in a row of phone photos that someone is supposed to "type up later." Later never quite comes, and the plan the room agreed dies on the wall. Here's how to run the same last-planner session on a screen so that every commitment lands as a dated Gantt activity, and the workshop ends holding a live, shareable schedule instead of a camera roll.
Pull planning works because the people who do the work build the plan. Trades stand at the wall, pull backwards from a target date, and negotiate the handoffs face to face — "I can't start the risers until you've closed the deck, so give me the deck by the 14th." The commitments are real because they're made out loud, to the person on the receiving end. That's the magic, and nothing about a screen should change it.
What the screen changes is what happens after. In the paper version, the wall is the deliverable — and a wall doesn't sequence, doesn't hold dates, doesn't refresh, and doesn't travel. Someone photographs it, and over the next week the commitments are re-keyed into a scheduler by one person who wasn't in half the conversations. Meaning leaks at every step. The fix isn't to abandon the sticky note; it's to make the sticky note be the schedule from the moment it's placed.
Why the wall of photos loses
Think about what a paper board actually produces. The commitments live only in people's heads and in a grid of colours that means nothing to anyone who wasn't there. There are no dates on it — a column is "week three," not the 14th to the 18th. There's no logic — the arrows are drawn by hand and forgotten by lunch. And there's no way to hand it to the person on nights, the client, or the trade who couldn't travel. The single most valuable hour on the project ends as an artefact that can't be scheduled, shared, or refreshed.
The category's two escape routes both fail. Reach for a heavyweight desktop scheduler and you can't run the room with it — nobody negotiates handoffs by watching a planner type into a form; the tool is too slow, too dense, and puts one person between the trades and the plan. Reach for a generic online whiteboard and you can move stickies around beautifully, but you still get a picture, not a programme — no dates, no sequence, no export to a real schedule. You end up doing the transcription anyway. The gap nobody fills is a board where the workshop output is the schedule.
Run the session so it ends as a schedule
Put Sketchedule on the big screen in the room and open the pull-planning board. Set the milestone you're pulling to on the right — say "Level 2 ready for finishes" six weeks out — and let the trades work backwards. The only rule that matters: every commitment goes on a note, and every note has an owner and a duration. Here's the flow from empty board to shared link.
- Open the pull-planning board. Start a new schedule and switch to the pull-planning / last-planner board. Drop the target milestone on the right-hand edge of the timeline — the thing the room is pulling towards — so everyone is planning backwards from a real date, not an empty grid.
- Add sticky commitments. As each trade names a piece of work, put it on a sticky note: a short verb ("close the deck"), the owner, and how long it takes. Colour by trade or by area. Because you're running it live, the room does this together — in the cabin on one screen, or across sites over the encrypted collaboration channel with everyone's cursors on the same board, nothing uploaded to a server.
- Sequence them. Drag the notes into handoff order along the timeline and link the dependencies as the trades agree them out loud — "risers can't start till the deck's closed." Each note snaps to a date; the board resolves the chain so the commitments carry real start and finish dates, not just "week three." Conflicts show up immediately, while the people who can fix them are still in the room.
- Convert to the Gantt. Flip the board to the Gantt view. Every sticky is already a dated activity — owner, duration and links intact — laid out as bars on a calendar with a summary bar over each trade or area. No transcription: the wall you just built is the schedule. Add a data date and you can crop it straight to a rolling look-ahead for the field.
- Share a read-only link. Send a read-only link the moment the meeting ends. The whole schedule travels inside the link, encrypted — the trade on nights, the client, the sub who couldn't attend all open the exact plan in a browser with nothing to install. Or export a clean PDF / PNG / PowerPoint for the wall, or publish it as self-contained HTML.
Live across sites, without losing the room
Pull planning assumes everyone's in one place. On a distributed job — a client three time zones away, a specialist sub who can't travel, a second site running in parallel — that assumption breaks, and the session either doesn't happen or happens twice. Running the board over the encrypted, peer-to-peer collaboration channel puts every participant on the same board at once: live cursors show who's touching what, a conflict-free merge means two people can place notes at the same instant without clobbering each other, and every change is captured in an in-document audit. Nothing is uploaded to a server — the board travels directly between the participants, end-to-end encrypted.
The point isn't the technology; it's that the distributed session keeps the thing that makes pull planning work — commitments made out loud to the person receiving the handoff — and still ends as one agreed schedule, not two half-plans to reconcile afterwards.
From board to a rolling look-ahead
Because the converted board is a real Gantt with real dates, it slides straight into the weekly rhythm. Drop a data date on it, crop it to the next six weeks, and you've turned the workshop into a short-interval look-ahead the crew reads on the wall — the same live view, re-cropped and re-shared each week. The plan the trades built together doesn't get filed and forgotten; it becomes the field's working schedule.
| Step | What the room does | In Sketchedule |
|---|---|---|
| Open board | Sets the milestone to pull towards | Pull-planning / last-planner board + target milestone |
| Add commitments | Names work, owner, duration on a note | Sticky notes, coloured by trade or area |
| Sequence | Orders handoffs, links dependencies | Drag to date; notes snap to real start/finish |
| Convert | Nothing — it's already done | Flip to Gantt: bars, summary bars, milestones |
| Across sites | Everyone on one board, live | Encrypted P2P collab, presence, CRDT merge |
| Share | Sends the plan to all who need it | Read-only link; PDF/PNG/PPT; publish HTML |
Key takeaways
- A paper pull-planning wall ends as photos to transcribe; run it on a screen and every commitment lands as a dated Gantt activity instead.
- The category can't do this: heavyweight schedulers can't run the room, and generic whiteboards only give you a picture — here the workshop output is the schedule.
- Place notes with an owner and duration, sequence the handoffs, and the board resolves real start/finish dates — no re-keying.
- Run it live across sites over the encrypted collaboration channel — one agreed schedule, not two half-plans to reconcile.
- Convert to the Gantt, crop to a look-ahead, and share a read-only link the moment the meeting ends.
Turn your next pull-planning session into a schedule
Open Sketchedule in a browser — free, no install, nothing uploaded. Put the board on the screen and let the room build a plan that's already dated.
Primavera and P6 are trademarks of Oracle Corporation; Microsoft Project is a trademark of Microsoft Corporation. Sketchedule is an independent product and is not affiliated with, endorsed by or sponsored by Oracle or Microsoft. Figures are illustrative, drawn in Sketchedule; Fig 3 is a faithful redraw of the pull-planning board and its converted schedule as built in the app.