We publish a starter automation at $499, one-off, with no monthly fee. It is the cheapest thing on our price list and the one people are most skeptical about, which is fair. The same work has historically been quoted at ten times that, and a number that low usually means something has been left out.

So here is exactly what fits in it, what does not, and why the floor is $499 rather than $199 or $2,000.

In short

One automation from a fixed menu of six: one trigger, one action, at most two systems, the exceptions you can name on the call, and documentation. It is live in ten business days. If your process needs a third system or a branch nobody can describe yet, it is not a starter automation, and we will say so before you pay for one.

Everything in that list constrains the shape of the build, not its quality. A $499 automation gets the same error handling, failure alerting, testing against your real cases and documentation as a $4,500 one. The floor is $499 rather than lower because below it you are dropping one of those, and each is load-bearing.

The definition, precisely

A starter automation is a single path between two systems. Something happens in one place; something consequently happens in another.

One trigger. A form submission, an inbound email, a record created, a scheduled time.
One action, or a short chain of them that all belong to the same outcome.
Two systems. The one it comes from and the one it goes to.
The exceptions you can state. Not every one, just the obvious ones. A missing email address, a duplicate, a value above a threshold.

Everything in that list is a constraint on shape, not on quality. A $499 automation gets the same error handling, the same failure alerting, the same testing against your real cases and the same documentation as a $4,500 one. What it does not get is more scope.

The six on the menu

Each is a single path between two systems, which is what keeps it at $499.

Automation	Trigger	What it does
Instant lead reply	A new inquiry by form	Replies in seconds by text and email, in your words, and alerts the owner
Missed-call text-back	A call goes unanswered	Texts the caller back with one fixed reply and logs the call
Review request	A visit or order completes	Asks for a review at the right moment, with a link to the platform that matters
New lead into CRM	An inquiry is submitted	Creates or updates the record and alerts the team with the details
Appointment reminders	A booking is made	Sends a confirmation, then a reminder before the appointment
Order or payment thank-you	An order or payment lands	Sends a thank-you in your words, with the details the customer needs

None of these is impressive on its own. Collectively they are where a surprising share of an administrator's week goes, and each of them is the kind of thing that gets dropped in a busy week, which is usually more expensive than the time it takes.

What is included, and why none of it is optional

The temptation at this price is to strip the build down to the happy path. We do not, because the parts people strip are the parts that decide whether it still works in March.

Error handling and retry logic. APIs time out. If the automation has no retry, you get silent gaps rather than a failure.
Failure alerting. It stops and tells a named person. An automation that fails quietly is worse than no automation, because you have stopped watching.
Testing against your real cases. Your actual historical records, not invented examples. This is where the undocumented exception surfaces.
Documentation in plain language. What it does, what it touches, what to check first when it misbehaves.
It runs in your accounts. Your platform subscription, your credentials in your vault. Removing our access does not stop it.

That list is why the floor is not lower. Below about this figure you are dropping one of those five, and each of them is load-bearing.

Why there is a floor at all

Every build carries the same fixed work regardless of ambition: understanding the process properly, designing the failure path, testing against real data, documenting it, handing it over. That overhead does not scale down to nothing just because the automation is small.

Which raises the obvious question: if it is that simple, should you build it yourself? Sometimes, genuinely, yes. A two-step connection between two modern apps with good connectors is an afternoon's work in Zapier or Make, and if you have somebody willing to own it, do that. We will tell you so on the call. What you are buying from us at $499 is not access to a secret. It is somebody doing the exception handling and the documentation that a self-build usually skips, and being responsible for it afterwards.

What does not fit, and what it becomes

Being honest about the boundary is more useful than being flexible about it. Four things push a job out of the starter tier, and it is nearly always the third.

If your process has	It becomes	Because
Three or more systems	A standard system, from $2,000	Each additional system is another API, another credential, another failure mode
Documents to read	Document processing, $3,500	Extraction, validation and a review queue for what fails the check
Exceptions nobody can list	Whatever scoping finds	The unlisted exceptions are the project. See below.
Language to understand	An AI agent, from $3,500	Needs an evaluation set and a confidence threshold, neither of which is small

The exception problem, in miniature

The most common reason a job leaves this tier is not complexity anyone intended. It is that the process turns out to have branches nobody mentioned, because nobody thinks of them as branches. They are just what you do for that one customer, or on Fridays, or when the value is over a certain amount.

A form-to-CRM automation is $499 until you discover that inquiries from three existing accounts have to skip routing and go straight to the account manager, that anything mentioning a particular product needs a different owner, and that Spanish-language inquiries go to a different person entirely. That is now a multi-step workflow, and the honest thing is to say so before starting rather than during. This is what the exception problem looks like at the small end.

Whether it pays back

At this price the arithmetic is usually clear, as long as the task is frequent.

A task done twice a day taking six minutes is about four hours a month. At $45 an hour fully loaded that is $180 a month, so the $499 clears in under three months and returns roughly $2,160 a year after that. At half that frequency, $90 a month, it takes closer to six.

Where it barely pays back is low frequency. The same six-minute task done weekly is 26 minutes a month, about $20, so the $499 takes over two years to clear, and a single $175 change adds nearly nine months to that. Frequency decides this more than any other factor; what should not be automated has the table.

One recurring cost belongs in the calculation: the platform subscription the automation runs on, typically $30 to $150 a month shared across everything you run. There is no monthly fee from us. The first 30 days after go-live are covered; after that, changes are $175 each on pay as you go, and fixes are billed as changes. Monitoring and fixes come with a Growth or Scale plan, which is optional.

The honest caveat about buying one

One starter automation rarely changes how a week feels. The visible difference comes from four or five of them removing the small, constant interruptions together. That is what the packages are for. Starting with one is still a perfectly reasonable way to find out whether we are any good, and the $499 is credited in full if you buy a full system within 90 days.

Where to start

Pick the thing that annoys someone daily. Not the biggest process, the most frequent irritation, because frequency is what pays and irritation is a decent proxy for it. If you cannot pick, that is what the scoping call is for. It is free, and the written proposal that follows is yours whether or not you build anything.

What a $499 automation actually gets you