Keeping the Customer and the Crew on the Same Schedule
The phone rings at ten past nine. It's the customer from the job you finished rough-in on last week: "Is anyone coming today?"
It's a two-minute call. It's also the fourth one this week, and every one of them lands while you're under a sink or halfway up a ladder. The information the customer wants is not secret and not complicated — someone's coming Thursday. The problem is that the only copy of that fact is in your head, so the only way to get it is to interrupt you.
That's what a shared schedule actually fixes. Not "collaboration" in the software sense — the specific, daily problem of being the single point of contact for a fact that four different people need. (This piece is about the sharing; the schedule itself is covered in Gantt chart for construction.)
Four groups, four different needs
The mistake is treating this as one job: "share the schedule." The four groups need genuinely different things, and one of them needs to be actively protected from some of what's in there.
| Who | What they need | What they must not see |
|---|---|---|
| The customer | Which days you're on site, what happens when, when they need to make a decision | Your rates, hours, margins, buffer |
| Your lead or foreman | The whole job, and the ability to change it when the site changes | Nothing — they need all of it |
| Subs and trades | Their own days, and what has to be finished before they arrive | Other subs' pricing, your margins |
| The office | Everything, mainly so nobody has to ring the site to answer a question | Nothing |
Read down that table and the design falls out of it. Most people need to see the schedule. Very few need to change it. And exactly one group needs a filtered version.
Why one schedule beats four copies
The common setup is a whiteboard in the office, a group chat with the crew, a printed week on the truck dashboard, and an email to the customer with dates in it. Four copies of the same information, and the moment one job slips they start disagreeing.
They don't disagree loudly. That's what makes it expensive. The whiteboard gets updated, the group chat gets a message, and the email from three weeks ago quietly becomes wrong. Nobody notices until a customer says "but you told me Tuesday" and they're holding a printout that says Tuesday.
One schedule, one copy, everyone looking at the same thing. When Thursday moves, it moves once and everybody's view moves with it. There's nothing to reconcile because there's nothing to reconcile against.
What the customer should actually see
Not everything, and not a wall of task names either. A customer wants three things:
When you're on site. The days they need to be home, keep the driveway clear, or keep the dog in.
What order it happens in. This is the one people underrate. A customer who can see that tile waits on inspection, and inspection waits on the plumber, understands why week two looks quiet. Without that, a quiet week looks like you've abandoned them for a bigger job.
When they need to decide something. Fixture selections, tile choice, the colour of the grout. Put those on the schedule as dated items and you stop being the person who chases. The date is on the plan; it isn't your opinion.
If a customer has never looked at a timeline before, a short orientation helps — how to read a Gantt chart covers what the bars, the arrows and the today line mean, and it's the sort of thing you can send once with a link.
One person moves the dates
The most common failure of a shared schedule isn't that nobody looks at it. It's that too many people can change it.
Three people who can all move bars will produce a schedule nobody trusts inside a fortnight, because when a date changes there's no way to know whether it changed for a reason or because somebody dragged something by accident. And once it isn't trusted, everyone goes back to ringing you.
So be deliberate about it:
- Editors — the people who plan the work. In most shops that's you, the office manager, and the lead. Two or three people, not everyone.
- Viewers — everyone else. The customer, the subs, the inspector, the client's designer. They see the live plan and they can't change it, which means you can hand it out freely without ever worrying about what someone might have moved.
The rule of thumb: if a person doesn't decide when work happens, they don't need to be able to change when work happens.
Setting it up without making a project of it
Two mechanisms, and the difference between them matters.
A link is for showing. Anyone with the URL can open a read-only page in a browser — no account, no app, nothing to install. That's what you send the homeowner or attach to a quote. You can revoke it when the job's done.
An invitation is for working together. It goes to one person, it carries a role, and you can take it back from that one person without affecting anyone else. That's what you use for your lead, your office manager, and the sub you want watching the plan for the next three months.
Send a link when you're saying "here's what's happening." Send an invitation when you're saying "you're part of this."
Whatever tool you land on, those two ideas are the ones to look for — a read-only view you can hand to anyone, and per-person access you can revoke. Our survey of Gantt chart tools compares how different products handle both.
The three conversations this ends
"When are you coming?" The customer looks it up. Ten seconds, no interruption to whoever is on the tools.
"Why is nothing happening this week?" They can see the inspection date and the tile that waits on it. A gap with a visible reason isn't a complaint — it's a plan.
"Who told them Friday?" Nobody told them Friday. The schedule says Thursday, it has said Thursday since Tuesday, and everyone including the customer is looking at the same Thursday.
That third one is the one that quietly costs the most. Sorting out who promised what, after the fact, with two people who each remember it differently, is the least productive hour in the trade.
It only works if it's true
A shared schedule is a promise that what's on it is current. Break that and it's worse than no schedule at all, because people act on it.
Two habits keep it honest:
Update the same day. Five minutes at the end of the day. When something slips, move it then — not Monday. There's a method for working out what a delay actually affects in what happens when one job slips.
Change it in one place. If a date moves in a text message and not on the schedule, you've just recreated the four-copies problem with extra steps. The schedule is the record; everything else points at it.
For small outfits this is most of what "process" needs to be — visibility rather than paperwork. Keeping a small team aligned covers the rest of the ground.
When the job's done
Cut the customer's access when the work is signed off. Not out of secrecy — a live link to a finished job just goes stale and gets forwarded to people you never intended to give it to.
Keep the schedule itself. A finished job with real dates on it is the best estimate you'll ever have for the next one like it, and it's the record that settles a warranty conversation two years later. It's also the raw material for pricing the next one properly — see how to price a job for what to do with those actual hours once you have them.
The short version
Everyone who needs to know sees the same schedule. Two or three people can change it. The customer gets dates and sequence, never rates. Links for showing, invitations for working together. Update it the same day, or don't bother.
Get that right and the ten-past-nine phone call stops. That's the whole return, and on a busy month it's a big one.