A role sync with a safety net underneath it
Three Make scenarios keep job roles in step between a master workspace and a public jobs portal: instant events for speed, a fifteen-minute sweep so nothing falls in the gap.
Where this applies
Any team that keeps a master list in one workspace and publishes a copy where the public can see it: job boards, marketplaces, listings, directories.
- scenarios, one outcome
- 3
- runs, one early error
- 292
- safety-net interval
- 15 min
The problem
Many teams keep their master records in one workspace and publish a copy somewhere the public can see them: job roles on a portal, listings on a marketplace. Copying by hand means the public side is always a little behind, and a record edited after the copy is wrong from then on.
The obvious fix, a webhook that copies on change, has an obvious weakness: webhooks occasionally do not arrive, and a form that writes a record and its children a moment apart means a copy that fires immediately reads a half-written record. And only the records that are meant to be public should ever cross over.
What we built
Three triggers, one outcome
One scenario fires when an employer is created and copies every role it has. A second fires on any change to a role. A third runs every fifteen minutes and looks for anything the first two missed. Each is small enough to read in a minute, and each can fail without taking the others with it.
Waiting for the form, not guessing at it
The employer-created scenario sleeps for forty-five seconds before it reads anything, because the form writes the role subitems after the parent exists. It is a blunt answer to a race condition, and a cheap one: the run costs six operations, and anything that arrives later is caught by the other two scenarios.
Update or create, decided by lookup
The change scenario finds the matching role on the portal by name. If it exists, a router writes every mapped field onto it; if not, the same router creates it. Writing the whole set each time, rather than only the changed column, means a cleared field clears on the portal too. Changes to the column that records applications are ignored. It churns constantly and is not role content.
Only open roles cross over
Every route checks that the parent employer's role sits in the open-jobs group before it does anything. Closed roles never reach the portal because nothing ever asks them to.
Window arithmetic for the safety net
The sweep reads the forty newest roles and acts only on those created between two and twenty minutes ago. The two-minute floor lets the instant scenarios go first, so the sweep rarely races them. The twenty-minute ceiling against a fifteen-minute interval overlaps successive runs by five minutes, so a role cannot slip between two polls, and because every create is preceded by a name check, the overlap is harmless. A sweep with nothing to do costs two operations.
The outcome
Roles reach the jobs portal without anyone re-keying them, and an edit on the operations side follows as soon as the change event fires.
Across the three scenarios there have been 292 runs and 622 operations. The sweep alone has polled 265 times with no misses recorded.
One error in the whole history: a permission failure on the first create, fixed straight away and not seen since.
Because creation always checks first, the three scenarios overlapping each other creates no duplicates.
Where it stops
Matching is by name, so renaming a role on the operations side creates a new one on the portal rather than renaming the old. The sweep looks at the forty newest roles, which is plenty at this volume and would need widening if hundreds of roles landed inside one twenty-minute window.
Built with
- Make.com
- monday.com
- GraphQL API
- Webhooks
Patterns used
- Upsert by lookup
- Safety-net polling
- Wait for the form
- Group filter
Page copy drafted with AI assistance. Skofi is accountable for it. Editorial policy
Have something shaped like this?
If any part of the above resembles a problem you are living with, a short call is the fastest way to find out whether it is the same problem underneath.
What happens on the call
- 15 minutes, no deck
- We map the process on the call
- A written scope, or an honest no