From Manual Process to Automated Pipeline in 48 Hours

48 hours is aggressive. But it's also realistic, if you pick the right process and don't let perfect be the enemy of working. This article walks through exactly how to go from "this process is completely manual" to "this process runs automatically" in two days — using a real example from a finance operations team at a mid-sized professional services firm.

The process in question: vendor invoice approval. Every week, 15–25 invoices come in by email. Someone on the finance team opens each one, logs it in a spreadsheet, emails the relevant department head for approval, follows up if they don't respond, logs the approval, and then queues it for payment. Start to finish, per invoice: about 12 minutes. At 20 invoices per week, that's four hours of finance team time doing pure administrative work.

Day 1, morning: Map the process before touching the tool

The instinct is to open the automation platform and start building. Resist it. The first two hours should be documentation.

Write down every step of the process as it currently happens. Not how it's supposed to happen — how it actually happens, including the workarounds and exceptions. For the invoice workflow, this means writing down: what triggers the process (invoice arrives by email), what information is captured (vendor name, amount, invoice date, due date, project code), who approves what (department heads above $500; controller above $5,000), what happens after approval (logged in accounting system, queued for next payment run), and what breaks (invoices without project codes, invoices from vendors not in the system, approvers who are out of office).

This map is what you'll build from. Skipping it means you'll build the happy path and discover the exceptions in production, which is significantly more expensive.

Day 1, afternoon: Connect your tools and map the fields

For this workflow, the tools involved were: a shared Gmail inbox for incoming invoices, a Google Sheet for the invoice log, Slack for approver notifications, and a simple internal web form for approval responses.

Connect each tool to your automation platform. For every connection, write down exactly what data is available and what format it comes in. For the Gmail trigger, that's: sender email, subject, body text, attachments. For the approval response form, that's: invoice ID, approver name, decision (approve/reject), notes.

Field mapping is where most automations break. Before building any workflow logic, have a document that says: "Vendor name comes from the form field 'vendor_name' as a text string. Amount comes from 'invoice_amount' as a number. Approver comes from the logged-in user's email." Know exactly what you're working with before you start wiring things together.

Day 1, evening: Build the happy path

Start with the scenario that works perfectly: invoice arrives, is logged, goes to the right approver, gets approved, gets logged as approved. Build exactly this. Don't add error handling yet. Don't add exception logic yet. Get the happy path running and test it with real data.

By end of day one, the workflow should be able to process a clean invoice end-to-end in test mode. This takes approximately 3–4 hours of actual building time — most of that on the field mapping and the approval notification format.

Day 2, morning: Add exceptions and error handling

Go back to your process map. For every exception you documented, add handling.

Invoice with no project code: branch to a "needs review" queue, notify the finance manager with a summary, pause the workflow until the code is added manually. Invoice from unknown vendor: same pattern — route to review, notify, pause. Approver out of office: add escalation logic — if no response in 24 hours, notify the backup approver.

Also add error handling for technical failures: if the Google Sheet update fails, send an alert to the finance team lead. If the Slack notification doesn't deliver, fall back to an email notification. These steps take another 2–3 hours but are what separates a workflow that holds up in production from one that breaks silently.

Day 2, afternoon: Test with real scenarios

Run five test invoices through the workflow:

• A clean invoice under $500 from a known vendor — should auto-route to the correct department head
• An invoice over $5,000 — should escalate to the controller
• An invoice with a missing project code — should go to the review queue
• An invoice from an unrecognized vendor — should flag for review
• An invoice where the approver doesn't respond — should escalate after 24 hours

Document what actually happens vs. what you expected to happen. Fix the gaps. For this workflow, the main issue was that the Slack notification wasn't rendering the invoice amount correctly — it was displaying as a string instead of a formatted currency value. Fixed in 20 minutes.

Day 2, end of day: Go live with one week of parallel running

Don't switch off the manual process immediately. Run both for one week. The finance team continues logging invoices manually, and the automation runs in parallel. Compare results daily: did the automation log the same invoices? Did it route correctly? Did it miss anything?

After a week of parallel running without discrepancies, turn off the manual process. At that point you have confidence the automation handles your actual invoice volume correctly.

Total time from start to go-live: 48 hours of calendar time, roughly 12–14 hours of actual work. The finance team got four hours per week back. The workflow has been running for six weeks without a failure that required human intervention. That's a reasonable definition of success.