Case Study · From our founder's work
An Hour of Daily Copy-Paste, Rebuilt as Six Minutes of Oversight
A six-day-a-week employee-lifecycle process spanning three systems that didn't talk to each other, rebuilt as a human-in-the-loop automation that runs in about six minutes — without giving up a single point of human judgment over live employee accounts.
~6 min
Per run, reviewed
was ~60 min expert · ~150 min peer
96%
Of the time eliminated
vs. the peer-operator baseline
$20K
Build quote replaced
built in-house, not outsourced
$120K
Role later absorbed
the capacity it compounded into
Jump to — sections marked deep dive are technical and skippable
At a glance
- Scope
- End-to-end employee-lifecycle automation across three systems that didn't talk to each other
- Cadence
- Six runs a week, Sunday through Friday, on a same-day compliance clock
- Time per run
- ~6 min human-in-the-loop — down from ~60 min (optimized expert) / ~150 min (a peer)
- Who can run it
- Anyone on the team — it used to require one specific expert to run at speed
- Build cost
- $0 outsourced — replaced a ~$20,000 development quote, built in-house with modern tooling instead
- Platform
- Google Apps Script driving the Google Admin SDK, bound to a Sheets workbook
- Design pattern
- Two-phase stage → review → execute; color-coded, idempotent, re-runnable
- Downstream effect
- Freed capacity compounded into absorbing a full ~$120,000 role — no second hire
The problem
Fragile, unshareable, and living in one operator's head
A national aviation-services company onboards, moves, and offboards hourly and salaried staff continuously across dozens of stations. Every one of those lifecycle events had to be reflected in Google Workspace — the identity backbone for company email, single sign-on, and access to the learning system.
But the trigger data lived in the HR system of record, the eligibility data lived in a separate I-9 verification system, and the accounts lived in Workspace — and the HR system needed information written back into it once accounts and eligibility were settled. Three systems, no integration between them, and a compliance clock on every new hire. The person in the middle of those three systems, six days a week, was Hunter.
None of it was hard in isolation. What made it heavy was the volume, the cross-referencing, and the frequency — all done by hand across systems that didn't talk. Hunter had already optimized the manual version about as far as it could go: formula-driven spreadsheets that did the lookups, and a programmable gaming mouse whose macros moved data between sheets and the admin console faster than a normal operator could. Fully tuned, he could finish a run in about an hour.
That's the optimized-expert baseline, not the real cost. When peers ran the same process it took them roughly two and a half hours— they didn't have the scaffolding, the macros, or the muscle memory for which edge cases mattered. The real problem was never just that it was slow. It was that the process was fragile, unshareable, and concentrated in a single operator.
About this case study
This is work StrAinge Business Solutions founder Hunter Strange built in an operations role at a national aviation-services company — not a StrAinge Business Solutions client engagement. It was the first end-to-end process he ever automated this way, and we publish it because it's the clearest illustration of how we approach automation: remove the toil, never the judgment. It ran in the same environment as our Dayforce → UKG migration case study — the "downstream HR-system migration" that later re-scoped this process was that project.
What he built
Automate the labor. Keep the human as the decision-maker.
The design goal was deliberately not full automation. Hunter rebuilt the entire process as a Google Apps Script application bound to the working spreadsheet, driving the Google Admin SDK directly — with the human retained as the person who confirms every change before it touches a live account.
The same run that took an hour of expert copy-paste now takes about six minutes — and anyone can run it in that time, not just Hunter. The crucial part: that six minutes still includes a human reviewing every account change before it executes.
The system splits into two phases that never blur together — a Stage pass that proposes and touches nothing live, and an Execute pass that runs only after a person has read the staged output. That review-then-execute seam is the whole philosophy.
Three systems, no integration between them
HR system of record
Dayforce — the lifecycle trigger: who was hired, moved, put on leave, or terminated
Employment eligibility
HireRight / I-9 — verification status that gates a same-day compliance clock
Google Workspace
Identity backbone — email, single sign-on, and access to the learning system
Google Apps Script · bound to the working spreadsheet
1 · Stage — touches nothing live
Pull live Workspace state
reads the current directory from the Admin SDK — decisions made against ground truth, not a stale export
Classify every employee
de-dupes the HR feed, matches HireRight status, and sorts each person into the correct lifecycle action
Write plain review sheets
who gets created, deleted, reactivated, suspended, held — proposed, not executed
Surface exceptions
anyone it can't confidently map goes to a separate tab instead of being guessed
Human review gate
The operator reads the staged sheets and confirms — in full — what is about to happen to real accounts.
Nothing below runs until a person has seen it.
2 · Execute — only after review
Apply account changes
create / reactivate / suspend / hold / delete via the Admin SDK, plus org-unit and group moves
Write back to the HR system
formatted files pushing business email and I-9 status changes back into Dayforce
Color-coded, per-row results
green for success, red for failure with the exact error written next to the row
Idempotent audit trail
re-run safely — completed rows skip — and produce a values-only historical backup
Result
Live Workspace reconciled + HR system updated
the same run that used to take an hour of expert copy-paste, done in ~6 minutes — with the human still deciding every irreversible action
How the human stays in the loop
Two phases, one review gate between them
The machine does the reconciliation, the string manipulation, the API calls, and the record-keeping — the parts that are mechanical and error-prone when done by a tired human at speed. The human does the part that requires judgment: looking at the list of accounts about to be created and deleted on real people and confirming it's right.
1 · Stage
With one menu click, the script pulls the current, authoritative state of Google Workspace live from the Admin SDK — replacing what used to be a manual export — de-duplicates the HR feed, validates that every active employee maps to a known site/role combination, and classifies every employee into the correct lifecycle action. It writes those decisions into plainly labeled review sheets — who gets created, who gets deleted, who gets reactivated, who gets suspended, who gets held— and surfaces any employee it couldn't confidently map onto a separate exceptions tab instead of guessing.
Staging touches nothing live. It only proposes. The operator sees exactly what is about to happen, in full, before anything executes.
2 · Execute
Only after the human has reviewed the staged output do they run the execution steps. Each executed row is written back with a color the operator can read at a glance — green for success, red for failure, with the specific error message written next to the failed row. A run can be re-executed safely; already-completed rows are skipped. Nothing is fire-and-forget, and nothing fails silently.
That review-then-execute seam is the whole philosophy. Six minutes of reviewed, deliberate oversight beats an hour of rushed heads-down data entry — on both speed and quality.
What the automation absorbed
The full lifecycle decision tree, encoded once
Every branch that used to be decided by hand, per employee, across three systems — now classified automatically from HR status plus current account state.
| Lifecycle event | What the script does |
|---|---|
| New hire | Create a Workspace account, generate a de-conflicted email, set the right org unit and groups, and write the business email back to the HR system. |
| Returning employee | Reactivate the account, move it back to the correct org unit, and re-add it to its groups. |
| Going inactive (leave) | Suspend the account and move it to the furlough org unit. |
| Termination — rank & file | Delete the account outright. |
| Termination — management / corporate | Quarantine on a hold — delegated mailboxes, retention obligations, and in-flight HR make hard deletion destructive. |
| I-9 / eligibility | Cross-reference HireRight status per employee and write the resulting status changes (pre-start vs. active) back to the HR system, same day. |
Email generation with collision handling
The tedious lookup Hunter used to do by formula and eye, now deterministic: the script builds first.last@domain, and if that address is already taken it walks to a middle-initial variant and then through the alphabet until it finds a free address — de-conflicted against everyone who already has one, every time.
The rest of the toil, gone
- Live-state reconciliation — pulls the real, current Workspace directory every run instead of trusting a stale export, so decisions are made against ground truth.
- The destructive-deletion safety rule — management and corporate accounts are protected from hard deletion and quarantined on a hold instead — deletion is permanent, so the rule is enforced in code, not memory.
- Cross-system write-back — generates the properly formatted files that push business email and I-9 status changes back into the HR system, closing the loop that used to be manual re-keying.
- A durable audit trail — every run can produce a flat, values-only historical backup — a record of exactly the state the process acted on.
The numbers
Faster than the expert, and no longer needing one
| Peer (manual) | Optimized expert | The automation | |
|---|---|---|---|
| Time per run | ~150 min | ~60 min | ~6 min |
| Reduction vs. baseline | — | 60% (personal tooling) | 96% vs. peer · 90% vs. optimized |
| Who can run it at that speed | one trained operator | one expert (Hunter) | anyone |
| Oversight of live changes | yes, but rushed | yes, but rushed | yes, and unhurried |
Against the cadence of six runs a week, the automation returned on the order of five-plus hours a week versus Hunter's own optimized baseline — and far more than that versus what the process actually cost when someone else had to run it. But stating that as a tidy annual dollar figure would understate it, because the reclaimed hours were never simply saved. They were redeployed.
The compounding effect
The freed time didn't go back into idle capacity — it went into automating and hyper-optimizing other areas of the business the same way. Each win freed more time, which funded the next optimization, which freed more time again.
That compounding produced a landslide: over the arc of this work, Hunter absorbed an entire additional full-time position — a role carrying roughly a $120,000 annual salary — without a second hire. The true return on this first automation isn't the weekly hours it saved. It's the capacity it unlocked to take on a second job's worth of value.
It de-risked the single point of failure.
The expertise moved out of one person's head and mouse macros and into a system anyone on the team could operate.
It raised fidelity while raising speed.
Automating the mechanical work made the process more accurate — human attention moved from copy-paste to reviewing the actual decisions.
It kept a human accountable for every irreversible action.
No live account is ever created, suspended, or deleted without a person having seen it on the review sheet first.
How it was built
The clever part isn't in the process. It's how the process got built — and stays alive.
This was the first end-to-end system Hunter automated with modern development tooling, and the distinction is the whole point.
There is no black box inside the running process.The automation itself is deterministic, auditable software — Apps Script and direct API calls. Nothing makes judgment calls on live employee accounts at runtime, and that's by design: a compliance-sensitive lifecycle process should be predictable, not probabilistic.
Modern tooling was how it got built — and how it stays adaptable.That is where the value hides, and it's easy to undersell:
It collapsed the build cost.
This kind of custom, three-system integration had been quoted at around $20,000 to develop through traditional channels. Using modern development tooling, Hunter built it himself — bypassing that cost entirely, while keeping complete understanding of every branch of the logic, because he directed its design rather than outsourcing it.
It removed the developer dependency permanently.
When a business rule changed — a new station, a new org unit, a shift in how terminations were handled — he could make the change himself, in the moment it was needed. No ticket, no waiting on a backlog, no re-scoping fee, no re-explaining the domain to someone who didn't live in it.
No build cost, no ongoing developer dependency, and full owner-level control of the logic. That's a different economic model for internal software than most organizations run on — and it's the model StrAinge Business Solutions is built to deliver.
Why this fits a five-person shop as well as a national one
The pattern is the product — and it doesn't care how big you are
This ran in an enterprise, but nothing about the approach is enterprise-specific. The same stage → review → execute skeleton is exactly what a small business needs for the back-office work that quietly eats its owner's week.
Strip this project down and what's left is a reusable shape: pull the real current state from wherever it lives, propose every change on a sheet a human can read, let a person approve it, then execute deterministically with a per-row record of what happened. That shape is domain-agnostic. We apply the identical method to the automations a small business actually asks for:
Accounts payable
Invoices come in; the system stages proposed GL coding and a payment batch; the owner approves what to pay; it executes and records it. The judgment call — what actually gets paid — stays human.
Accounts receivable
Staged invoices and dunning reminders, reviewed before they go out, then sent and logged — so nothing slips and nothing embarrassing sends itself to a client.
HR onboarding & offboarding
The exact process on this page, at 20 employees instead of thousands: accounts, email, access, and paperwork created and revoked on a reviewed, repeatable run instead of a founder's memory.
Compliance & payroll prep
Reconcile the systems that don't talk, stage the changes on a same-day clock, and keep an audit trail — the parts that are risky to do by hand at speed.
And the economics that made it work matter more at small scale, not less. A five-person business can't carry a $20,000 build or a standing developer relationship — but it's exactly the place where one automated, owner-controlled process, changeable the day the business changes, is the difference between hiring for the back office and not needing to.
What made it work
Five decisions carried the project
All five transfer to any process, at any size.
Automate the labor, not the judgment.
The goal was never to remove the human — it was to remove the toil so the human's judgment could be spent where it matters. Six minutes of reviewed oversight beats an hour of rushed data entry on speed and quality.
Design for the operator who isn't you.
The biggest win wasn't shaving an hour to six minutes — it was that the two-and-a-half-hour version stopped existing. Good automation dissolves the gap between the expert and everyone else.
Understand the process deeply before you automate it.
Hunter could only compress this because he had personally run every branch of it, by hand, six days a week, until he knew which edge cases mattered. The automation encoded hard-won operational knowledge — it didn't paper over a process nobody understood.
Respect irreversibility.
When software acts on real people's accounts, "mostly right" isn't good enough. The whole architecture is built around a review gate precisely because some of these actions — deletion above all — cannot be undone.
Own the software, don't rent it.
Modern tooling collapsed a $20,000 build into something Hunter could construct and — more importantly — keep changing himself. The organizations that win with automation aren't the ones that buy the most software; they're the ones that can adapt theirs the day the business changes.
The through-line
Remove the toil. Keep the human on the decisions that can't be undone.
Done right, that's not a trade-off between speed and control — it's how you get both, whether you're onboarding thousands of people a week or paying a stack of invoices on a Friday.
Have a back-office process that lives in one person's head?
Onboarding, accounts payable, AR, compliance prep — the repetitive, cross-system work that's too risky to fully hand off. That's exactly the shape we automate, with you still deciding what matters. Let's talk about yours.
Book a Strategy Consult