Real-estate investment, off-market residential acquisitions and wholesale dispositions
GoHighLevel Dispositions Engine: Multi Sub-Account CRM Automation
Both stages run against live CRM sub-accounts. The hand-off is live for one region; the second region's copy is built but not yet in service.
- Our role
- Automation architect and sole builder
- Timeline
- Built in phases alongside live operations
- Sector
- Real-estate investment, off-market residential acquisitions and wholesale dispositions
What was breaking
GoHighLevel is excellent inside one sub-account and deliberately walled off between them. Sub-accounts do not share contacts, pipelines, custom fields, or workflows, and crucially, the same logical field (say, a property's asking price) has a completely different internal field ID in each sub-account. That isolation is the right default for an agency managing unrelated clients. It is a serious obstacle when a single business deliberately uses several sub-accounts as departments.
This operation had three: two regional acquisition desks sourcing off-market residential deals, and one central dispositions desk that markets finished properties to a cash-buyer list. A property that cleared underwriting in a regional account had to appear in the dispositions account as a marketable property card. Because nothing crosses that boundary automatically, somebody opened two browser tabs and copied roughly thirty fields across, address, beds, baths, square footage, lot size, year built, condition notes, ARV, repair estimate, asking price, title status, occupancy, access instructions, and the rest.
The second half was worse. Once a property was ready to market, the dispositions team needed to reach every cash buyer who actually buys in that property's county, while respecting do-not-contact status and several suppression lists built up over years of burned relationships. That meant filtering a buyer list by county by hand, checking each buyer against the suppression lists from memory, pasting the property details into an email or SMS template per buyer, and then manually opening a deal record for each one so follow-up could be tracked. A property with forty county-matched buyers was most of an afternoon.
Roughly 30 fields re-typed per property
Every transcription was a chance to put the wrong ARV or asking price in front of a buyer, the kind of error that costs credibility with a cash-buyer list you cannot rebuild quickly.
Buyer matching did not scale
Fan-out effort grew with the buyer list. As the list got more valuable, marketing each property got slower, exactly the wrong incentive.
Suppression was memory-based
Do-not-contact, dead buyers, and blacklisted contacts were enforced by whoever happened to be doing the send. One lapse means contacting someone who explicitly asked not to be contacted.
No per-buyer tracking
Because deal records were created by hand or not at all, nobody could answer 'which buyers have seen this property, and who hasn't replied?' without reconstructing it from an inbox.
Speed is the product
In wholesale dispositions the first credible offer usually wins. Hours of manual preparation between 'property ready' and 'buyers notified' is margin leaking out of the business.
What we built
I built the system as two independent, idempotent stages joined by the CRM itself rather than one long pipeline. Stage one moves a property across the sub-account boundary. Stage two markets it. Keeping them separate matters: a property usually needs a human to confirm or add details after it lands in dispositions but before it goes out to buyers, and a single monolithic automation would have run straight past that checkpoint.
The cross-account copy is, at its core, a translation table. Because the same field has a different ID on each side, the automation holds an explicit source-ID-to-destination-ID mapping for every property attribute, and writes all of them in a single update call rather than one call per field. On top of the copied values it derives several it can compute: which region the deal originated in, an initial deal status, the date it landed, and two target dates calculated from the source record, including one scraped out of a free-text timeline field so that 'close in about 45 days' becomes an actual date the CRM can filter and report on.
The marketing stage is where the real leverage is. When a property is moved into the ready-to-market stage, the automation reads its county, derives the matching buyer tag from it, and searches the dispositions sub-account for contacts carrying both that county tag and the buyer tag, while explicitly excluding do-not-contact status and every suppression tag. For each buyer who survives that filter, it stamps the full property specification onto their contact record, so the team's existing CRM email and SMS templates can merge the property details natively with no external mail tooling. It then tags the buyer with both a property-specific tag and a push tag, which is what the client's own CRM workflows trigger from. Finally it opens one dispositions deal card per property-and-buyer pair, priced at the asking price with a follow-up date two days out.
Idempotency is deliberately achieved by asking the CRM rather than by keeping state in the automation layer. Before copying a property, the automation searches the destination pipeline for a card with that address. Before opening a buyer deal card, it searches that buyer's existing cards for this property. Because the check reads the same system the write targets, there is no cache to go stale and no separate store to reconcile, and an operator who re-runs the whole thing gets no duplicates.
The CRM is the state, the automation is stateless glue
No external queue, no sync database, no bookkeeping tables. Every decision is made by querying the CRM live. A back-reference field on each buyer record points at the property card it came from, and a push timestamp records when, so the audit trail lives where the team already looks.
Two stages with a human checkpoint between them
The copy lands a property in an intake stage. A person reviews it and sets the county, and nothing can be marketed until they do, because the county is what buyer matching keys on. The gate is structural rather than a policy someone has to remember.
Suppression is a filter in the query, not a step afterwards
The buyer search excludes do-not-contact and all suppression tags at the point of selection. A suppressed buyer is never in the result set, so no later step can accidentally include them.
Tags as the integration surface
Rather than having the automation send messages itself, it writes tags the client's own CRM workflows already listen for. The client keeps full control of messaging and can change templates without touching automation.
One write call, not thirty
All property attributes go up in a single update per record. Thirty separate API calls per property would have been slower, far more fragile, and would have burned through rate limits on a large fan-out.
Non-negotiables
- The CRM had to stay the system of record. The team lives in GoHighLevel all day; a parallel database they had to check as well would have been ignored.
- No changes to how the acquisitions teams work. Both regional desks kept their existing pipelines and stages, the automation attaches to a stage they already use.
- Suppression and do-not-contact had to be enforced in code, not by convention. This is the one failure mode with consequences beyond lost revenue.
- Re-running anything had to be safe. Operators press buttons twice; the pipeline must not produce duplicate properties or duplicate buyer outreach when it happens.
- Field mapping had to be explicit and reviewable, because the two sides of each mapping are opaque IDs that mean nothing to a human reader.
The pipeline
Drawn as text and shapes rather than shipped as an image, so the step labels stay readable and downloadable.
Stage 1: Cross-sub-account property hand-off
Moving a cleared acquisition into the dispositions sub-account with its full specification. The duplicate check reads the destination CRM, so re-running the stage is safe.
- Trigger
- Processing step
- Branch / filter
- Error handling
- Data store or CRM
- Human checkpoint
- Primary path
- Conditional or exception path
Stage 2: County-matched cash-buyer fan-out
One property becomes outreach to every eligible buyer in its county, plus one tracked deal card each. Suppression and do-not-contact are applied in the buyer query itself.
- Trigger
- Branch / filter
- Error handling
- Processing step
- Delivered output
- Primary path
- Conditional or exception path
How the work runs
Each stage, what it does, and the specific failure it is built to prevent.
A cleared deal reaches the hand-off stage
The acquisitions team carries on exactly as before. When a deal is underwritten and ready to be sold, they move it to the pipeline stage they already used for that. No new habit, no new tool, the automation attaches to an existing step in their process.
Attaching to an existing stage rather than a new one means adoption cannot fail by people forgetting a new step.
Properties are pulled and re-read in full
The automation searches that stage for deals, then re-fetches each one individually. The second read is not redundant: the CRM's search response does not include custom field values, and the custom fields are the entire payload here. Skipping the re-read is the single easiest way to build this and get silently empty properties.
Guards against copying property cards with every specification field blank.
The destination is checked before anything is written
Each property's address is searched for in the destination pipeline. If a card already exists, this property is skipped entirely. This is what makes the stage safe to re-run, and re-running is the normal recovery path when a batch partially fails.
Prevents duplicate property cards, which would in turn duplicate buyer outreach downstream.
The property card is created, then filled in one write
A card is created in the dispositions intake stage, owned by a fixed placeholder contact, property cards represent assets, not people, so attaching them to a real contact would pollute contact records. The specification then goes up as a single update containing every mapped field, rather than a call per field.
One write per property instead of ~30 keeps the run fast and well inside API rate limits.
Derived values are computed rather than copied
Alongside the copied attributes, the automation writes values it can work out: the originating region, an initial deal status, the date it landed, and two target dates. One of those dates is parsed out of a free-text source field; the leading number is extracted from text like 'about 45 days' and turned into a real date, which converts prose nobody could filter on into something the CRM can report and automate against.
Falls back to sensible defaults when the source text has no parseable number, so a malformed note cannot block the copy.
A person confirms the property and sets the county
This is the deliberate human checkpoint. Several fields, the county above all, are completed after the copy, by the dispositions team. Because buyer matching keys on county, a property simply cannot be marketed until someone has reviewed it. The quality gate is enforced by the data model rather than by policy.
Structurally impossible to blast an unreviewed property to a buyer list.
Eligible buyers are selected in a single filtered query
Moving the property to ready-to-market starts the fan-out. The county is slugified into the matching buyer tag, and the CRM is searched for contacts carrying both that county tag and the buyer tag, excluding every suppression tag, dead buyers, do-not-call, blacklisted, and system-only records. Suppression happens in the query, so a suppressed contact never enters the result set at all.
The highest-consequence rule in the system is enforced at selection time, where it cannot be bypassed by a later step.
Each buyer gets the property stamped onto their record
For every buyer who passes the do-not-contact check, the full property specification is written onto their contact record. This is the trick that avoids external mail tooling entirely: because the details live on the contact, the client's existing CRM email and SMS templates merge them natively, and the client can rewrite their messaging whenever they like without anyone touching the automation.
A back-reference to the source property card and a push timestamp are written too, so the trail is auditable in the CRM.
Tags trigger the client's own outreach workflows
Each buyer is tagged with a property-specific tag and a push tag. The automation never sends a message itself; it hands off to workflows the client owns. That boundary keeps messaging, compliance, and send timing under the client's control, and means automation changes and marketing changes never collide.
One tracked deal card per property and buyer
Finally, a dispositions deal card is opened for each property-and-buyer pair, priced at the asking price, assigned to the responsible user, with a follow-up date two days out. Before creating it the automation checks that buyer's existing cards for this property, so duplicates cannot accumulate. The result is a real pipeline the team can work: every buyer who has seen a property is a card, and 'who hasn't replied?' becomes a pipeline view instead of an archaeology exercise.
Card creation failures for one buyer are swallowed deliberately so a single bad contact record cannot halt a fan-out mid-list.
What it runs on
Every tool listed with the job it actually does in this build.
Platform
GoHighLevel
The system of record across three sub-accounts, two regional acquisition desks and the central dispositions desk. All state, all tags, all pipelines, and all outbound messaging live here.
Orchestration
Make.com
The orchestration layer. Chosen over writing a service because the client's team can open a run, see every module's payload, and understand what happened without a developer, which matters for a system they operate daily.
Integration
GoHighLevel REST API
Used directly rather than through pre-built connector modules, because cross-sub-account field mapping and compound tag filtering need request-level control the connectors do not expose.
Data
PostgreSQL (Railway)
Stood up as a reporting backbone for the dispositions pipeline, queryable independently of the CRM so analytics never contend with operational API limits.
Google Sheets
The legacy reporting and underwriting layer the business already ran on, kept readable throughout the migration rather than cut over abruptly.
What stopped being manual
Snippets are illustrative and generic. No client data appears in any of them.
Cross-sub-account field translation
The manual act this replaces: a person with two browser tabs open, reading a value out of one CRM sub-account and typing it into a differently-named field in another, roughly thirty times per property. The automation holds the mapping explicitly and resolves each source field by ID out of the property's custom-field collection.
javascript
// Each property attribute is looked up by its source field ID and written
// to the destination field ID. The two sub-accounts share no ID space, so
// the mapping IS the integration. It is written out in full, not inferred.
const value = get(
map(source.opportunity.customFields, "fieldValue", "id", SOURCE_FIELD_ID),
1
);
// ...all mapped attributes go up in ONE update call, never one per field.County to buyer-tag derivation
Replaces reading a county off a property and eyeballing which buyers cover it. The county string is normalised into the exact tag the buyer list uses, so matching is deterministic rather than interpretive.
javascript
// "Los Angeles County" -> "county-los-angeles"
const countyTag =
"county-" +
lower(replace(replace(county, " County", ""), " ", "-"));
// Buyers are then selected by county tag AND buyer tag,
// MINUS every suppression tag, all in one query.Free-text timelines into real dates
Replaces a human reading a note like 'needs to close in about 45 days' and working out a date. The leading integer is extracted and added to today, with a default when the text has no number at all, turning prose into a field the CRM can filter, sort, and automate on.
javascript
// "close in about 45 days" -> a real date 45 days out.
// Falls back to a sane default when nothing parseable is present,
// so a malformed note degrades instead of blocking the copy.
const target = addDays(
now,
ifempty(parseNumber(replace(sourceText, /^\D*(\d+).*$/, "$1")), 30)
);Ask-the-CRM idempotency
Replaces the human habit of checking whether something was already done. Instead of tracking state in the automation, every write is preceded by a read of the system being written to.
javascript
// Before creating a buyer deal card, look for one that already
// pairs this property with this buyer. The check reads the same
// system the write targets, so there is no cache to go stale.
const exists = toString(map(existingCards, "name"))
.includes(propertyAddress + " - " + buyerName);What it was worth
The headline change is that marketing a property stopped being an afternoon's work. The manual path was: copy thirty fields between sub-accounts, filter the buyer list by county by hand, check each buyer against the suppression lists, paste details into a template per buyer, and open deal records one at a time. The automated path is: move a card to a stage, review it, move it again.
The less obvious win is that the pipeline became measurable. Because every property-and-buyer pair is a real deal card with a price and a follow-up date, questions that previously needed someone to dig through an inbox (which buyers have seen this property, who hasn't responded, how many active conversations exist per property) are now just pipeline views. The business got reporting it never had, as a side effect of automating the data entry.
And the compliance posture changed in kind rather than degree. Suppression used to be enforced by whoever was sending; now a suppressed contact cannot enter the result set, because the exclusion is part of the query that selects buyers. That is the difference between a rule people follow and a rule the system makes unbreakable.
GoHighLevel sub-accounts integrated
Two regional acquisition desks plus a central dispositions desk, each with its own field ID space.
Property fields carried across the boundary
Written in a single update per property rather than one call per field.
Fields stamped onto each matched buyer
So the client's own CRM templates merge property details natively, with no external mail tooling.
Property to buyer fan-out
One stage change reaches every eligible buyer in the county and opens a deal card for each.
Exclusion rules enforced at query time
Five suppression tags plus CRM do-not-contact status, applied when buyers are selected.
Fields re-typed between sub-accounts
The transcription step, and its error class, is gone entirely.
Handed over
- A cross-sub-account property hand-off that carries ~28 specification fields from a regional acquisitions pipeline into the central dispositions pipeline, with explicit field mapping in both directions documented.
- A county-matched buyer fan-out that writes the property spec onto each eligible buyer, tags them for the client's own outreach workflows, and opens one tracked deal card per buyer.
- Suppression and do-not-contact enforcement built into the buyer selection query, covering five distinct suppression lists plus CRM do-not-contact status.
- Idempotency on both stages, so operators can safely re-run after a partial failure without producing duplicate properties or duplicate buyer outreach.
- Derived-field logic: region stamping, initial status, landing date, and two computed target dates including free-text timeline parsing.
- A queryable PostgreSQL reporting layer for the dispositions pipeline, separate from the operational CRM.
- A documented field-mapping reference, which is the piece that makes the system maintainable; the raw IDs are meaningless without it.
Questions about this build
What teams usually ask when they recognise their own process here.
No. Sub-accounts are isolated by design. They do not share contacts, pipelines, custom fields, or workflows, and the same logical field has a different internal field ID in each one. Moving records between sub-accounts requires an external automation that holds an explicit field-ID mapping and talks to the API on both sides. That mapping is the bulk of the work, and it is why this kind of integration cannot be done with a simple one-click connector.
Because the client operates this system every day and needed to be able to see what happened. In Make, an operator can open a run and inspect the exact payload at every step without a developer. A bespoke service would have been cheaper to make elegant and far more expensive to support. Where Make was not enough (compound tag filtering, single-call multi-field writes) I dropped to direct REST calls instead of connector modules, which gives request-level control while keeping the run inspectable.
By making the exclusion part of the query that selects recipients, not a step that runs afterwards. Here the buyer search requires the county tag and the buyer tag while excluding do-not-contact status and five separate suppression tags, so a suppressed contact is never in the result set. If filtering happened after selection, any later bug could leak past it; filtering at selection means there is nothing to leak.
Nothing bad, which was a design requirement. Before copying a property it searches the destination pipeline for that address; before opening a buyer deal card it searches that buyer's cards for that property. Both checks read the same system the writes target, so there is no stale cache and no separate state store to reconcile. Re-running is the normal recovery path after a partial failure.
So the client keeps control of their messaging. With the property spec on the contact, their existing CRM email and SMS templates merge the details natively, no external mail tool, no duplicate template to maintain, and no deliverability domain to manage. The automation's job ends at writing data and applying tags; the client's own workflows decide what gets said and when, and they can change that without anyone touching automation.
Yes (the shape is generic. Any business running several GoHighLevel sub-accounts as departments has the same boundary problem, and any business that matches inventory to a segmented contact list has the same fan-out problem. Franchise groups, multi-location service businesses, and brokerages hit this constantly. What changes between industries is the field mapping and the matching key; the architecture) stateless glue, CRM as state, exclusion at query time, idempotency by asking the system, carries over unchanged.
The honest answer is that the mapping discovery takes longer than the automation. Enumerating pipelines, stages, and custom-field definitions across three sub-accounts, where every field is an opaque ID, is most of the effort, which is why I built dedicated read tooling to do it rather than clicking through the UI. Once the mapping is known, each stage is a few days of work. Budget most of the timeline for discovery and documentation.
Capabilities this used
Read next
All gohighlevel services workHave a process that works like this one did?
Book a strategy call. We will walk the workflow with you and say plainly which parts are worth automating and which are not.