Transfer Automation — In Plain English

The same plan, told simply. No jargon. What each piece is for, and the headache it takes away.

The big problem

Right now, the whole transfer process lives in Kelsey's head. She keeps track of every operator, every lease, every follow-up — in HubSpot, in Evernote notes, in snoozed emails, and in her memory. It works today, but it all rests on one person. As we do more deals, that gets harder, and if she's out, the knowledge walks out the door with her.

There's a deeper issue underneath. Most of this work is routine — send the letter, chase the operator who hasn't replied, file the signed paperwork, notice when the money starts coming in. Only a little of it needs a person to actually think — a confusing reply, a number that doesn't match, an operator who's gone quiet. The trouble is those two kinds of work are mixed together, so a person has to babysit all of it. The boring 90% ends up stealing the attention that the tricky 10% deserves.

The whole goal, in one line

Make transfers feel like handling the occasional exception, not running a machine by hand. Let the software do the routine chasing and filing. Save the humans for the real decisions.

The idea: break the work into small pieces

Instead of one giant process that one person runs, we split the work into small building blocks. Each block does exactly one job. Each one takes over a specific chore that used to live in Kelsey's head, or guards a specific spot where a human still needs to decide.

Why one job each? Because when a single thing tries to do two jobs, it gets confusing and breaks in surprising ways. Keep each piece simple and focused, and the whole system stays easy to understand, fix, and trust. Below are the pieces, in plain terms — what each one does, and the headache it removes.

The pieces

Getting a closed deal into the system

The Draft (the plan calls it "staging")

What it doesHolds a safe, editable copy of a deal's numbers before any of it becomes official.

The headache it removesThe person closing the deal works in a messy spreadsheet — screenshots, scratch math, columns moved around. That mess can't be the official record. But if you edit the official record directly, one typo can damage real data. The Draft gives everyone a safe place to fix things where mistakes cost nothing until you say "go."

The Preview (the "confirm intake" screen)

What it doesShows a full list of everything that's about to happen, and waits for a person to approve it.

The headache it removesPressing "go" on a new deal fires five things at once — it updates the records, opens tickets, moves the folder, and emails the operators. You can't un-send an email. The Preview is the last look before all of it happens, so nothing reaches an operator by accident.

The Cost Split (cost-basis allocation)

What it doesTakes the one price we paid for the whole deal and splits it fairly across each individual lease.

The headache it removesTexas taxes minerals lease by lease, so each lease needs its own cost on the books. We buy at one blended price. Without a fair split, there's no defensible number per lease — and no way to back it up if the IRS asks.

Keeping track of the work

The Transfer Thread (a HubSpot "ticket," one per operator)

What it doesGives each operator its own single thread that tracks the transfer from first letter to finished.

The headache it removesOne deal often involves several operators, each moving at its own pace. Without one thread per operator, "where does the Foree Oil transfer stand?" has no single answer — the status is scattered across emails and notes.

The Needs-Me Pile (the "Needs Attention" column)

What it doesCollects only the items that actually need a person to think — and nothing else.

The headache it removesIf everything is flagged as important, nothing is. Kelsey ends up digging through a long list that's mostly stuff she doesn't need to touch. This pile holds only the real decisions, so her attention isn't wasted on noise. Everything in the pile matters equally — no "extra urgent" flags to argue over.

The Auto-Chaser (follow-up cadence)

What it doesSends polite follow-up emails on a set schedule to operators who haven't replied.

The headache it removesToday, follow-ups depend on Evernote notes and snoozed emails in one person's memory. Forget one, and a transfer quietly stalls for weeks while the money keeps going to the wrong party. The Auto-Chaser never forgets.

The Reply Reader (reply classification)

What it doesReads an operator's email reply, figures out what it means, and only acts on its own when it's very sure.

The headache it removesReading every reply by hand is most of the daily grind. But acting wrongly on a confusing reply is worse than doing nothing. The Reply Reader handles the clear ones automatically and hands the unclear ones to Kelsey. Two safety nets: it won't act when it's unsure, and Kelsey can switch it off entirely with one message.

Talking to operators

The Heads-Up Letter (change-of-ownership email)

What it doesTells the operator we now own the interest and asks them to pause payments — right away, then again once the deed is officially recorded.

The headache it removesUntil the operator is formally notified, they keep paying the old owner — so every day of delay leaks our money to the seller. Recording the deed takes weeks, so we can't wait for it. This sends notice immediately with the unrecorded deed, then follows up with the official one later.

Finding the Right Person (contact resolution)

What it doesMatches a loose company name like "Foree Oil" to a real contact we can actually email.

The headache it removesThe deal notes carry rough names, not real contacts. You can't email a name, and guessing wrong sends a legal notice to the wrong company. This pins the loose name to a real person before anything goes out. And if we still guess wrong, the letter itself asks them to point us to the right party.

The Expected-Number Note (pinned NRI note)

What it doesPuts the decimal we expect right at the top of the ticket, so Keegan can check it against the operator's paperwork when he signs.

The headache it removesThe expected number lives in a spreadsheet Keegan didn't build. Without it in front of him, he'd either sign blind or waste time re-figuring a number we already checked. He's just confirming the operator got it right — not redoing the math.

After we own it: watching the money

Is the Money Flowing? (revenue status / "in-pay")

What it doesTracks whether a lease has actually started paying us.

The headache it removesToday someone has to watch the revenue system and tell Kelsey when checks start — an easy handoff to drop. It also keeps getting confused with "is the paperwork done?" Those are two different questions, and this keeps them separate.

The Change Catcher (drift detection)

What it doesCompares each incoming check to what we expected, and flags anything that doesn't line up.

The headache it removesOperators quietly change decimals and deduction terms. If nobody checks each payment against our records, we can be underpaid for months without noticing. This catches the drift and puts it in the Needs-Me Pile.

Handling the paperwork

The Auto-Filer (document routing)

What it doesWhen a document is uploaded, it figures out which transfer it belongs to and files it there automatically.

The headache it removesWe get 15 to 35 division orders a month, on paper and by email. Filing each one by hand is tedious and easy to get wrong, and a single misfiled document quietly stalls a transfer. If it can't tell where a file belongs, it leaves it alone and emails a person — it never guesses wrong.

One Home per Deal (the folder structure)

What it doesGives every deal one predictable folder layout, from diligence all the way through transfer.

The headache it removesWithout one standard layout, documents end up scattered in random folders — finding a deed means hunting, and the software has nowhere reliable to look. Everyone (and every automation) knows exactly where things go.

Same Lease, Different Deals (master leases)

What it doesRecognizes when a lease we buy in one deal is the same physical lease we already own from another.

The headache it removesThe same lease can come in through several deals. Without linking them, our position in one lease gets split across disconnected records and we can't see the full picture.

The Undo Trail (history & audit)

What it doesKeeps a recoverable record of every change — nothing is ever truly deleted.

The headache it removesCorrections and re-runs overwrite what was there before. Without a trail, you can't answer "what did this say before, and who changed it?" — which we need for taxes and audits.

How the pieces hand off to each other

The pieces don't get tangled together. They stay separate and simple, and they pass work to each other through clear hand-offs. Here are the important ones in plain terms.

The big one — starting a deal: when Kelsey approves the Preview, six things happen together as a single all-or-nothing step: records go live, a thread opens for each operator, the folder moves, the Heads-Up Letters go out, and the deal is stamped with who bought it. If any part fails, the whole thing is cancelled — no half-finished mess.

Into the Needs-Me Pile: the Auto-Chaser gives up after its last follow-up → the item goes to Kelsey. The Reply Reader isn't sure → goes to Kelsey. The Change Catcher spots a mismatch → goes to Kelsey. A document can't be filed → Kelsey gets an email.

Paperwork moving things along: a signed division order gets filed → a courtesy email goes to the operator. The recorded deed comes back → the official follow-up letter goes out. A confirmation arrives → the thread closes.

On purpose: things we keep separate

Just as important as the hand-offs are the connections we deliberately don't make:

Money arriving does NOT close a transfer. A lease can start paying before the paperwork is finished. Closing early would hide a missing signature. "Is the money flowing?" and "is the work done?" stay separate.
Dropping the deed in the folder does NOT start the process by itself. That's a person's "I'm done" signal to the reviewer — a human still kicks off the next step on purpose.
The Monday nudge is not the same as the Needs-Me Pile. The pile is "decide this now." The nudge is a gentle "these have been sitting a while, in case you forgot." Two different things.

What's working well, and what to fix

Looked at this way, the plan is in good shape. It already does the smart thing in most places — keeping the money question separate from the paperwork question, sending one clever letter instead of two, keeping the urgent pile flat and honest. Two things are worth acting on.

Fix #1 — Add an "Operator Cheat-Sheet"

What's missingA place to record each operator's quirks — who insists on ink-signed originals, who's always slow, who prefers phone over email.

Why it mattersRight now that knowledge lives only in Kelsey's head — which is exactly the problem this whole project is trying to solve. It's cheap to add (a few checkboxes on each operator), and three other pieces would use it: the Auto-Chaser could wait longer on slow operators, the paperwork step could mail ink originals to the ones who need them, and the Monday nudge could stay quiet about operators we know are just slow. This turns "things Kelsey knows" into "things the system knows."

Fix #2 — Guard the "start a deal" step

The riskThat one approval fires six things at once. It's the right design — you want it to be one decision — but it's also the riskiest spot.

What to checkMake sure that if any one part fails partway through, all of it is undone. The folder-move already does this. The real danger is a half-finish — say, tickets get created and the folder moves, but an email fails. We want to be certain no operator ever gets emailed for a deal that didn't fully go through.

When each piece gets built

The order doesn't change from the original plan — this just says which pieces come online when.

Already done: One Home per Deal (the folders and templates). No automation yet — just the shelves.
Next (intake): The Draft, the Cost Split, the Preview, Transfer Threads, the first Heads-Up Letter, Finding the Right Person, Same Lease/Different Deals, the Expected-Number Note — and the big "start a deal" hand-off. Good spot to add the Operator Cheat-Sheet.
After that (chasing & replies): The Auto-Chaser, the Reply Reader with its safety nets, the Needs-Me Pile, "Is the Money Flowing?" (marked by hand at first), the Monday nudge.
Then (automatic money-watching): The Change Catcher, and "Is the Money Flowing?" flips on by itself.
Then (paperwork triggers): The Auto-Filer wakes up and starts routing uploads.
Last (cleanup): Move older in-progress deals into the new system.

The Undo Trail runs quietly underneath everything from the intake step onward.

Our guiding bet: trust the smart tool, not the rulebook

There's a well-known lesson from 70 years of building computers to do smart things (Rich Sutton's “The Bitter Lesson”). In plain terms: the systems that win long-term are the ones that lean on a general, ever-improving smart tool — not the ones where people try to hand-write every rule for how the work should go. Writing all the rules yourself feels productive and works for a while, but it plateaus, becomes a chore to maintain, and gets left behind as the smart tools get smarter.

That matters for us because we aren't building the smart tool — we're building on top of one (Claude) that keeps getting better on its own. So our version of the lesson is simple:

Lean on the tool — keep our rules thin

For the messy, judgment-y parts — reading an operator's email, figuring out which transfer a document belongs to, sensing that an operator is slow — let the smart tool do the work instead of us writing brittle rules. Design it so that as the tool gets smarter, we delete rules rather than pile on more. A few examples of the shift:

The Reply Reader — let the tool read every reply, and keep keyword rules only as a cheap shortcut we're happy to throw away. (Not “rules first, tool as backup.”)
The Auto-Filer — let the tool read what's inside a document to file it, instead of forcing everyone to name files a rigid way to feed a parser.
The Operator Cheat-Sheet — instead of Kelsey typing in “slow” or “wet-ink,” let the system notice those habits from each operator's actual history over time.

But keep these exact and hand-built

The lesson has a hard boundary. Anything that must be exact, legal, or can't be undone stays deterministic — no “smart guessing”:

The Cost Split — real tax math with IRS rules. A tool “figuring out” the numbers is a bug, not a feature.
Recording deeds and appraisal-district filings — legal paperwork, must be precise.
The “start a deal” step — it fires real emails and moves real money; it must run by exact, all-or-nothing logic.

Two reasons this boundary is real for us and not just caution: we only see 15–35 documents a month (nowhere near enough for a system to “learn” safely), and our mistakes cost real money and legal standing — not a lost game.

The good news: the plan is already built to do this safely. Our safety nets — the Preview, the Needs-Me Pile, the “only act when sure” floor, and the off-switch — mean a person always catches a mistake before it does harm. That's exactly what lets us hand the messy work to the smart tool without fear.

The rule of thumb

Every time we're about to write a new rule, convention, or checklist, ask two questions: “Will a smarter tool make this pointless in a year?” and “Is there a safety net so it's fine to just let the tool handle it?” If yes to both — don't build the rule. Save the hand-built precision for the math, the legal filings, and the things we can't take back.

How to use this document

This is the plain-English tour. The detailed version — exact schedules, folder names, database details, and open questions — lives in the full plan (transfer-automation-plan.html) and the piece-by-piece breakdown (transfer-automation-plan-concepts.html). When someone suggests a change, the simple test is: does it fit into one existing piece, does it try to make one piece do two jobs (split it), or is it a brand-new job nobody owns yet (like the Operator Cheat-Sheet)?