The Starting Point
Not broken. Just manual — and everything that comes with that.
The business was running. Orders were coming in, rentals were going out, customers were being served. But the way it was being done was almost entirely manual. Orders came in through calls and texts. Someone would write down the details, look up availability, calculate pricing, follow up, send the agreement, chase the payment — every step requiring a person to make a decision and then manually carry it to the next one.
That's fine when volume is low. It stops being fine when any one of those manual steps introduces an error — a wrong date, a miscalculated price, a customer who never got their payment link — and there's no system to catch it before it becomes a problem for the client.
"They didn't hire me to fix something that was breaking. They hired me to build something that wouldn't. The goal was efficiency, accuracy, and getting the highest-risk manual steps out of human hands entirely."
What I was walking into wasn't a rescue job. It was a ground-up build. And that came with its own kind of pressure — no existing system to reference, no established flow to improve. Just a business that needed a backbone, and the trust that I could build one.
The Approach
A month of building, iterating, and making it hold.
It took a month. Not because the individual pieces were complicated on their own, but because a system this connected requires every layer to work before the next one can be trusted. We tried multiple approaches to certain steps along the way — particularly around item availability and order timing — before landing on solutions that were actually reliable and sustainable.
The original plan for checking item availability and drop-off timing used a set of Make scenarios. They worked, but they were more fragile than I was comfortable with and harder to maintain. I replaced them with something better: a centralized Google Sheet running on Google Apps Script that handles the entire operational backbone of the business — inventory, pricing, scheduling, requests, and calendar — all in one place, connected to GHL through Make, returning values automatically.
"For it to work was the project. But to do it in the most efficient, navigable, and digestible way possible — that's what I held myself to. Every workflow named for its exact purpose. Every step justified. If something could be shortened by using a different tool, it was."
I was trusted to build this with no prior experience at this scale. That anxiety kept me careful. Every node had to make sense not just to me, but to anyone who might open the system later — a teammate, a new hire, someone who had never seen it before. Good automation doesn't require the person who built it to be in the room.
Tools Used
The stack that runs it.
GoHighLevel
Make (Integromat)
Google Sheets
Google Apps Script
Stripe
GHL Native SMS & Email
GHL Pipelines & Custom Fields
Webhooks
8-Stage Order Lifecycle — Tools at Each Step
Entry
Order comes in via form, SMS, or Mastersheet
GoHighLevelGoogle SheetsWebhooks
Data Layer
Mastersheet handles inventory, pricing, scheduling
Google SheetsApps ScriptMake
Pricing
Subtotal, delivery fee, and tax calculated automatically
MakeApps ScriptGoHighLevel
Invoicing
Stripe invoice created and sent — no manual input
MakeStripeGoHighLevel
Confirmation
SMS + email sent with reservation details and payment link
GoHighLevelGHL SMSGHL Email
Payment
Stripe confirms → GHL updates → delivery pipeline opens
StripeMakeGoHighLevel
Logging
Reservations log updated, calendar synced automatically
GoHighLevelMakeGoogle Sheets
Guardrails
Pipeline filters, data clearing, and duplicate checks at every stage
GoHighLevelMake
How It Works
Eight stages. One connected system.
The ordering system covers the full lifecycle of a rental — from the moment a client submits a booking to the moment their order is logged in the reservations calendar and delivery is scheduled. Each stage hands off cleanly to the next through a combination of GHL workflows, Make scenarios, and the centralized Mastersheet.
1
Entry Points: Three ways in, one system to receive them all
Orders can come in three ways: through the GHL booking form, via SMS (tagged and routed automatically), or through the Mastersheet's Quote Form Place Order button. Each entry point feeds into the same pipeline. For SMS orders, a tag triggers the handler automatically. For Mastersheet orders, a webhook fires the moment the assigned user clicks Place Order — GHL is searched for the customer by phone number, the contact is created or updated, and the order status is set to Placed. From there, every order regardless of source moves through the same downstream flow.
2
The Mastersheet: The operational backbone of the entire business
The centerpiece of the system is a centralized Google Sheet running on Google Apps Script. It handles everything that originally required manual lookup and calculation — item catalog and stock availability, pricing scripts, delivery scheduling, rental days calculation, the reservations log, and calendar sync. When an order comes in, Make pulls from the sheet, runs the checks, and writes the results back into GHL as custom field values. The sheet is the single source of truth. GHL is where those values live on the customer record. Make is what moves data between them.
3
Pricing Calculation: Subtotal, delivery fee, tax — calculated automatically
Once item availability is confirmed and order timing is classified as On Time or Rushed, a Make scenario pulls the order data from the Quote Form and runs the pricing scripts. Subtotal is calculated based on items and rental days. Delivery fee is determined by zone or distance. Tax is applied according to rules set in the sheet. The Total Rental Price is written back into the customer's GHL contact record. No manual math. No quoted price that differs from the invoice.
4
Stripe Invoice: Payment link created and sent without manual input
When the Order Status reaches Request Payment, a Make scenario fires. It retrieves the total price in cents format from the Mastersheet, searches for the customer in Stripe, and either creates a new Stripe customer or uses the existing one. The invoice is created, the Invoice Status field in GHL is updated to Invoice Sent, and an internal note is added to the contact record. New customers and returning customers are handled through separate router paths — no manual Stripe entry at any point.
5
Confirmation SMS & Payment Link: Customer gets everything they need in one shot
Once Invoice Status is set to Invoice Sent, a GHL workflow fires. It first runs a guardrail to confirm the order belongs to the JVMR pipeline — preventing unrelated contacts from falling in. It removes the customer from any active drip campaigns, clears chatbot fields to avoid conflicting automated responses, notifies the assigned user internally, and sends the customer both an SMS and an email with their reservation details and payment link. Contact type is set to Lead until payment is confirmed.
6
Payment Confirmed: Stripe fires, GHL updates, the delivery pipeline opens
When Stripe confirms a successful payment, a Make scenario retrieves the customer, finds their GHL profile, and updates Invoice Status to Paid and Order Status to Pending. A GHL workflow then fires automatically — removing the customer from all prior flows, upgrading Contact Type from Lead to Customer, incrementing their Total Orders count by one, and adding a detailed order note to the record. The customer receives a payment confirmation SMS, a tutorial SMS with equipment guides, and an email with order details and add-ons. The rental agreement process is initiated at this same step.
Delivery Branching Logic
- Rushed order (today or tomorrow): An opportunity is created in the Delivery Pipeline and a same-day task is assigned to the user to call and confirm delivery details.
- Standard order: An opportunity is created in the Delivery Pipeline and a Make webhook is called to calculate and set a task deadline three days before the delivery date.
- Error branch: The assigned user is notified — no customer should reach this branch under normal conditions.
7
Reservations Log: The order is recorded and the calendar is updated
When Order Status is set to Pending — meaning fully paid and awaiting delivery — a GHL workflow calls a Make webhook that writes the complete order into the Reservations Log table in the Mastersheet. Customer name, contact info, order ID, rental items, delivery and pickup dates, payment status, and order status are all recorded. The Mastersheet's built-in scripts then update the system calendar automatically. Deliveries and pickups are scheduled without anyone manually entering a calendar event.
8
Guardrails Throughout: The system protects itself at every step
One of the deliberate design choices across this system is the use of guardrails at each critical transition point. Old data from previous customers is cleared before new order data is written. Source fields confirm orders belong to the correct pipeline before workflows fire. Router logic prevents duplicate contacts, conflicting communications, and wrong-branch processing. The naming conventions across every workflow, scenario, and field were set intentionally — so that any teammate, or anyone new to the system, can open it and understand exactly what each piece does without needing to ask.
The Outcome
Seconds, not back-and-forths.
Before the system, a new order meant a chain of manual steps — writing down details, checking availability separately, calculating pricing by hand, sending a payment request manually, following up, logging it somewhere. Each step a chance for something to go wrong.
After, a new order takes seconds to process. The assigned user enters the details in the Mastersheet Quote Form and hits Place Order. Everything downstream — the contact record, the availability check, the pricing calculation, the Stripe invoice, the payment link, the confirmation messages, the rental agreement, the delivery pipeline, the reservations log, the calendar — runs on its own.
8
Connected workflow stages covering the full order lifecycle end to end
3
Entry points — booking form, SMS, and Mastersheet — all feeding the same pipeline
1
Centralized Mastersheet serving as the operational backbone across the entire system
0
Manual steps required between order placement and payment confirmation
Before vs. After: Order Processing
|
Before |
After |
| Order intake |
Calls and texts, details written down manually |
Form, SMS, or Mastersheet — all auto-routed |
| Availability |
Manual lookup, separate from the order flow |
Mastersheet checks and returns values automatically |
| Pricing |
Calculated by hand per order |
Apps Script runs subtotal, delivery, tax automatically |
| Invoicing |
Manual Stripe entry per customer |
Make creates the invoice and sends the payment link |
| Calendar |
Manually entered delivery and pickup events |
Mastersheet scripts sync calendar on order confirmation |
| Error risk |
Each manual step a chance for wrong data |
Guardrails and pipeline filters at every transition |
Looking Back
Bittersweet to watch it work.
I was trusted to build this with no prior experience at this scale. That's not something I took lightly. The anxiety that came with it wasn't noise — it made me more careful. More deliberate. More insistent that every single step run exactly the way it was supposed to.
When it was finally operational, it was bittersweet. On one hand the job was done. On the other, finishing meant moving on — and there's always something strange about leaving something you spent a month building from nothing.
But what that project gave me isn't something I can leave behind. It raised my bar. It showed me what I'm capable of taking on, and gave me the kind of confidence that only comes from doing something hard and watching it hold. The next project like this won't carry the same anxiety. It'll carry the same care — but now backed by the proof that I can do it.
🔗
Everything connected
GHL, Make, Stripe, and the Mastersheet operate as one system. Data flows in one direction and updates everywhere it needs to be.
🧱
Built to be navigated
Every workflow named for its exact purpose. Every step justified. Someone who has never seen the system can open it and understand what it does.
🛡️
Guardrails at every turn
Duplicate checks, pipeline filters, data clearing before new orders write in. The system is designed to protect itself from its own edge cases.
📋
One sheet to run it all
The centralized Mastersheet replaced fragile multi-scenario logic with a single, maintainable source of truth that handles inventory, pricing, scheduling, and calendar sync.