How a High-Ticket Content Agency's Disconnected Tools Were Consolidated Into a Single Logic-Gated OS

The agency was scaling; the systems holding it together were not: what worked as a small operation turned into a set of holes and leaks as volume grew.

The operation ran on Notion documents and databases that were not linked to each other, containing "supposed to be the same" information in multiple places. The work was pipeline-like, but no pipeline had actually been built. Tasks had no working statuses, deadlines, or notifications, so things slipped through the cracks.

The manual overhead landed on the owner: he held several high-paying positions himself and was ready to hire more people to cover the gaps.

But increased headcount wouldn't have helped, or might even have made it worse, because the gaps were systemic.

The "cost" showed up in three places: errors and misses, some of them expensive; service quality under strain; and too much of the owner's day spent inside the process, manually handling things.

Four main leaks:

• Communication in disarray. Creators emailed random inboxes or individual staff members. Threads went missing. There was no single record of who said what.
• Post scheduling. Setting the right publish slot for each client, in each client's time zone, ate hours. Creators often gave less than the required notice.
• Content sorting. When raw footage arrived, someone had to sort it by hand. It was one of the largest time sinks in the operation.
• Contract creation. The owner named this as the single most time-consuming task in the entire flow.

First, we worked with the process: architecture precedes construction on every build we do. We mapped and refined the agency's procedures first, then let the data topology follow the real flow of work.

The system is built as a set of interrelated databases: Clients, Creators, Shoots, Collaboration Requests, Video Editing Tasks, Deliverables, Comments, and a Music log. Each lives as its own entity, and relational links tie them together, so a single shoot connects to its client, its property, its creator, its editing tasks, and its initial request.
That interconnection allows the team to reach every related record from any record in one step. This is what turns a pile of documents into a system.

The toolstack, by architectural function:

• The Intake Layer (Typeform): Captures every collaboration request and client onboarding detail through structured inbound and outbound forms. Dynamic URL variables tag each submission with metadata before it enters the system, so records arrive pre-populated with needed information.
• The System of Record/Data (Notion): Houses the core interrelated databases and the team's working views, most calculations for third-party automations (Zapier), and its own automations. It is the single source of truth the whole pipeline reads from.
• The Routing Engine (Zapier): The primary automation layer. It moves some parts of data between records, fires time**-** and time-zone-specific notifications, and keeps the connected tools in sync.
• The File-Infrastructure Builder (Make.com): Triggered by webhook, it builds the Dropbox folder tree for each shoot and creates the upload links for needed folders.
• The Heavy-File Vault (Dropbox): Holds raw footage that database tools cannot carry. Upload links let creators send multi-gigabyte files without an account.
• The Scheduling Subsystem (Airtable): A decoupled slot engine for post dates. It renews available time-zone-specific slots per client, tracks what is taken, and shows each creator the times in their own zone (inside the Creator Portal). This is the one job Notion could not do, so we moved it out.
• The Creator Portal (Softr): A filtered, secure view where each creator sees only their own shoot data, dynamically pulled from Notion and Airtable (slots).
• The Comms Layer (Gmail / Zoho): Threads all external notifications into one email chain per shoot, so a creator gets a single thread instead of fifteen separate messages.
• The Internal Signal Layer (Slack): Routes event alerts to the specific team member responsible for the next step.
• The Editing Bay (Frame.io): Handles editing and revisions off-system, wired back into the pipeline through automation.

Logic gates control movement between stages. Each one either routes data forward or holds it until conditions are met.

• The Intake Gate. Every collaboration request enters through a structured form. A team member, through a CRM-like process, sorts each one into reject, hold, or contact, and the "winners" automatically become scheduled shoots.
• The Missing-Fields Gate. A formula watches each shoot for required data. Until every needed field is filled, the contract, file-building steps, and other automations stay locked. This stops unfit records from moving downstream.
• The File-Infrastructure Gate. One trigger builds the full folder structure for a shoot, using names as identifiers. A three-layer failsafe catches any naming error, falling back from property level, to client level, to a dedicated agency folder, so nothing is ever lost or misplaced.
• The Contract Gate. One checkbox generates a pre-filled contract based on the shoot type. The data the system already holds does most of the work.
• The Deadline and Time-Zone Engine. Because a Notion formula change cannot fire an automation on its own, the system re-checks every record on an hourly cycle. A set of notifications and email reminders goes out to both creator and client on a schedule, each adjusted to the client's own time zone, and falls into one email thread.
• The Manual Gates. Some stages are held until a manual action is taken by an automatically picked and notified responsible individual.

The agency now runs on one consolidated, documented system instead of a stack of disconnected parts. Every shoot moves along a defined pipeline, from first request to final post. Deadlines and notifications now exist where there were none.

The estimated operational shifts:

• Manual operating hours down an estimated 30 to 35%.
• Content-sorting overhead down roughly 80%, because files now arrive pre-sorted in the correct folder. Only exceptions and edge cases still get placed by hand.
• Contract creation an estimated 85 to 90% automated.

The largest change is harder to put a number on. The owner stepped back from running the daily operation: work that once needed his direct attention now runs through the system, half of it automatically.

The agency owns the system: we consolidated the documentation, overviews, and setup instructions into structured folders the client keeps. From those, the team has built its own SOPs.