Every startup I've worked with has the same conversation at some point:
"We know this is manual and we should automate it. We just haven't had time."
Six months later, the same conversation happens. The manual process is now bigger, slower, and harder to fix. Two engineers leave partly because they're tired of babysitting a Google Sheet that runs the business.
The problem isn't a lack of intent. It's a lack of a framework for deciding what to automate, when to do it, and how to approach it.
Here's the framework we use.
Step 1: The Automation Audit
Before writing a single line of code, map what's manual. This takes 2–3 hours and prevents months of building the wrong thing.
The inventory question: For every team, ask: "What do you do every day that feels like it shouldn't require a human?"
You're looking for:
- Repeated data movement — copying data from one system to another
- Status updates — someone manually checking a thing and then telling someone else about it
- Threshold monitoring — "I check this number every morning and email someone if it's above X"
- Report generation — pulling data from multiple sources into a format for someone else
- Approval routing — a thing that needs to go from A → B → C → D
Write these all down without filtering. You'll typically surface 15–30 candidates in an hour.
Step 2: The Prioritization Matrix
Not everything on your list is worth automating. Prioritize using two dimensions:
Volume: How often does this happen? Daily is 52x more impactful to automate than weekly.
Time cost: How long does it take per occurrence? A 2-hour daily process is a much better target than a 5-minute monthly one.
Multiply them: Volume × Time = Total hours per month consumed by this manual process.
A process that takes 30 minutes and happens 20 times per month consumes 10 hours of a human's time. Automating it completely recovers 10 hours per month—permanently.
Now filter by a third dimension: complexity to automate. Some things that look complex are actually simple (a few API calls and a cron job). Others that look simple are deceptively hard (anything involving unstructured data, human judgment, or external dependencies you don't control).
Your priority targets are: high hours consumed, low complexity to automate.
Step 3: Build vs. Buy Decision
This is where most teams go wrong. They either:
- Buy a tool that almost-fits and spend months configuring workarounds
- Build from scratch when a $50/month tool would have done the job in a day
Here's the simple framework:
Buy (off-the-shelf or low-code) when:
- The process is standard and the tool market is mature (e.g., Zapier for simple webhook-based automation, Notion for documentation workflows)
- You need it working this week, not next month
- The process is unlikely to need deep customization
- You're under 20 people and don't have dedicated engineering capacity for internal tools
Build (custom script or internal tool) when:
- The process is specific to your business and no off-the-shelf tool fits well
- You need deep integration with your existing systems
- The volume is high enough that per-transaction costs of SaaS tools become expensive
- You need to embed logic that requires real code (not visual flow builders)
- You've already tried the buy path and it doesn't work
The trap to avoid: Building something when a tool would work. This is almost always driven by engineers who prefer to build. The result is internal tools that are fragile, undocumented, and eventually become the thing nobody wants to touch.
What Good Candidates Look Like
After dozens of automation projects, here are the highest-ROI targets we see repeatedly:
Lead/deal routing and enrichment Most sales teams manually look up leads, paste data between tabs, and then assign them to reps. A simple script can do this in seconds—enriching with company data, scoring, and routing automatically.
Deployment and release processes Anything that involves a human running a checklist before pushing to production is automation-worthy. This is also where bugs live.
Status reporting Weekly status reports assembled by hand from 4 different tools. This is a script and an API key.
Customer onboarding steps The sequence of things that happen when a new customer signs up—account creation, notifications, configuration, assignment—is almost always partially or fully manual in early-stage companies.
Internal alerts and monitoring "I check the database every morning" should never be a job. If a threshold is crossed, a system should tell you. Not the other way around.
A Real Example
One team we worked with had two engineers spending about 4 hours per week pulling data from three internal systems, combining it in a spreadsheet, and emailing it to leadership every Monday morning.
The automation took 6 hours to build: a Python script that hit three APIs, combined the data, formatted it as a table, and sent it via email on a cron schedule.
ROI: 4 hours/week × 52 weeks = 208 hours/year recovered. At a $150/hour blended engineering rate, that's $31,200/year of value from 6 hours of work.
This is not unusual. It's typical.
Starting This Week
Here's how to get started without overwhelming your team:
- Run the inventory — block 2 hours, get the relevant people in a room, fill the whiteboard with everything manual
- Score and prioritize — rank by hours consumed × automation complexity
- Pick one — the highest-ROI, lowest-complexity item on your list
- Build or buy in a sprint — time-box it to 1–2 weeks maximum
- Measure and document — track the hours saved, document how it works, then move to the next one
The goal isn't to automate everything at once. It's to build a habit of systematically replacing manual work with reliable systems.
Over 12 months, that habit compounds into a team that is dramatically more productive at the same headcount.
Want help auditing what to automate in your company? Let's talk.