monday.com connects data horizontally within an item very well, and for dates it also connects vertically: timeline and dependency columns let a change to one item’s dates shift the items that depend on it. The gap is other data types. If you need a time of day, a number or another value to cascade from one item to the next, there’s no native equivalent, because monday’s formulas are scoped to the item they sit in. The reliable fix is a direct webhook integration that listens for the changes that should trigger a recalculation and cascades the values down instantly. This walkthrough shows that pattern built for a travel business managing itinerary times, and it applies wherever one item’s value should set the next item’s starting point.
Where monday already handles this, and where it doesn’t
It’s worth being precise, because monday solves part of this natively and it’s easy to reach for a custom build you don’t need.
Dates are handled. If your sequencing runs on dates, monday’s timeline and dependency columns do the job. Set dependencies between items and shifting one moves the items that depend on it. For project schedules running across days and weeks, that’s the right tool and no integration is needed.
Other data types aren’t. The moment the value you need to cascade isn’t a date, there’s no native equivalent. A time of day in an hour column, a running number, a value that should carry from one item to the next, none of these flow down on their own. And formulas don’t close the gap, because a monday formula is scoped to the item it sits in, so it can read across that item’s columns but can’t reference the item above it.
That’s the actual limitation, and it’s the one this walkthrough solves.
Watch the walkthrough
The scenario: itinerary times that stay in sync
This was built for a business in the travel industry planning itineraries where timing is sequential within a day. Each element has a start time and a duration, and the finish time of one element is the start time of the next.
Note the data type, because it’s the whole reason this needed building. These are times of day, not dates, so dependency columns don’t apply. Horizontally it’s simple: start time plus duration gives finish time with a formula, all within the one item. Vertically there’s nothing native to carry that finish time down to the next item’s start time.
Previously the client ran it in a spreadsheet, updated by hand, out of sync the moment anything moved.
How the solution works
Automatic webhook attachment. This is what makes the pattern practical rather than fragile. When you save a monday project as a template and create new projects from it, webhooks normally need authenticating again each time, which is a real barrier to using this at any scale. We built a trigger that attaches the required webhooks automatically whenever a new project is created from the template. One trigger, four connected triggers, one webhook, no repeated authentication.
Four events that trigger a recalculation. The integration listens for the four things that should change the schedule:
- A start time changes
- A duration changes
- A new item is added
- An item is deleted
Any of these fires the webhook, which recalculates and cascades the affected times down the board.
Group-level boundaries. Each group is treated as its own segment, so times flow down within a group and the next group isn’t affected. For an itinerary that means one day, or one leg, can shift without dragging everything after it out of place.
The result is that extending a duration, inserting an element in the middle, or deleting a step all reflow the schedule immediately, with nothing left stale.
Why a webhook integration rather than a workaround
You can approximate vertical connection using Connect Boards and mirrored columns, and for very simple cases that’s fine.
At real complexity it becomes brittle. You end up maintaining relationships between items by hand, updates aren’t immediate, and the setup gets harder to understand every time someone extends it. A direct webhook integration is simpler to reason about and updates instantly, because it responds to the actual events rather than depending on a chain of mirrored links holding together.
Where else this applies
The travel itinerary is the example, not the limit. The pattern fits wherever a non-date value should carry from one item to the next:
- Events and production: run sheets where each element’s finish time sets the next one’s start
- Field services and scheduling: job sequences across a day, where one appointment running long moves the rest
- Manufacturing: production runs sequenced by time within a shift rather than by date
- Construction: day-level sequencing on site, where site works are planned by hour rather than by date
- Professional services: delivery sessions and workshops planned to the hour
- Any running value: cumulative numbers, carried-forward quantities, or other values that should build down a list
The test is simple. If your sequencing runs on dates, use dependencies. If it runs on times of day, numbers or another data type, this is the pattern.