Claude Code for Small Business: 10 Automations in a Week

Email is the number-one bottleneck in most SMBs. These first two automations are the simplest and the ones with the highest immediate impact.

1. Automatic triage of the shared inbox. A `/triage-emails` skill checks the `info@` or `sales@` inbox every hour via Gmail MCP, classifies emails into five categories (sales inquiry, technical support, invoice/billing, spam, other), applies labels, and assigns priority. Urgent ones trigger a Slack notification. Spam goes to auto-archive. Implementation time: 2-3 hours. Monthly savings: 8-15 hours depending on volume.

The skill fits in less than one page of markdown. The slow part is deciding the classification rules: what counts as "urgent," which keywords mean sales inquiry vs support. That rule-thinking work is yours, not Claude Code's, but it's done once.

2. Reply drafts for repetitive sales inquiries. Once emails are triaged, a second skill `/draft-reply` reads the inquiry, identifies the most likely use case, drafts a reply following company templates, and saves it as a Gmail draft (doesn't send). The salesperson reviews, adjusts if needed, and sends. Implementation time: 3-4 hours. Monthly savings: 10-20 hours.

The key here is that Claude Code drafts using the tone and structure you define in `CLAUDE.md` or in templates inside the skill. It's not a generic response, it's the response you'd give in your style. The human still reviews before sending, but starts from 80% done.

Invoice management is usually split between the accountant, an Excel sheet, and the manager's email. That makes it a perfect one-day automation candidate.

3. Vendor invoice processing. A `/process-invoice` skill triggers when an invoice arrives by email or is uploaded to a Drive folder. It extracts tax ID, amount, date, number, and concept via OCR. Validates against the ERP or a spreadsheet (vendor exists, expected amount, correct VAT). If everything matches and it's under the auto-approval limit, it logs the entry. If there's a discrepancy, it sends a Slack message with the summary for human review. Implementation time: 4-6 hours. Monthly savings: 6-12 hours.

4. Weekly bank reconciliation. Every Monday, a cron hook launches the `/bank-reconciliation` skill. The skill downloads bank movements via the bank's MCP (or reads an exported CSV), compares them against logged invoices and pending payments, identifies discrepancies, and generates a three-line report on what doesn't match. It only notifies the responsible person if there are discrepancies. Implementation time: 3-5 hours. Monthly savings: 4-8 hours.

Reconciliation is the classic task that piles up because "it's not urgent" until it becomes hell at month-end. Automating it weekly turns a half-day monthly pain into five minutes of review every Monday.

SMBs typically have underused CRMs because keeping them current is manual work. Claude Code reverses the logic: the CRM maintains itself from the emails and meetings that already happen.

5. Automatic incoming lead qualification. When a new lead arrives via web form or email, a `/qualify-lead` skill enriches the information (public web search, LinkedIn via connector, company domain), applies the scoring model you define (target sector, size, budget signals), creates the contact in the CRM via MCP, and assigns to a salesperson per the routing rule. If the lead is high priority, it notifies on Slack within a minute of arrival. Implementation time: 4-6 hours. Monthly savings: 6-15 hours.

6. Sales meeting summary and next steps. A `/meeting-summary` skill receives a meeting transcript (Fathom, Otter, Granola), generates a structured summary with decisions made, next actions with owner and date, and pending topics. Creates tasks in the CRM or task system (Notion, Asana, ClickUp) and emails the summary to the client and internal team. Implementation time: 3-4 hours. Monthly savings: 8-12 hours.

Real savings go beyond time: the CRM stays current without effort, and commitments don't fall through because the salesperson forgot to update the customer record. Follow-up quality improves notably.

SMBs publish little because creating content consumes time from people with other priorities. Claude Code handles the mechanical part and leaves the strategic part to the human.

7. Content recycling across formats. A `/recycle-content` skill takes a long content piece (a blog, a webinar, a podcast episode) and automatically generates versions for LinkedIn (3 posts), X (a thread), newsletter (a summary), and Instagram (a carousel script). It preserves the brand voice and tone defined in `CLAUDE.md`. Pieces are saved as drafts in the content manager (Buffer, Hootsuite, or a shared file). Implementation time: 3-5 hours. Monthly savings: 8-20 hours.

8. Automated monthly marketing report. On the first of each month, a cron triggers the `/marketing-report` skill. The skill pulls Google Analytics, Search Console, social media, and CRM via MCP, calculates the month's key metrics, compares them with the previous month and the quarter's goal, and generates a one-page PDF for the leadership team or client. Implementation time: 5-8 hours. Monthly savings: 4-8 hours.

The monthly report is the classic case where someone spends half a day copying numbers from five different dashboards. Once automated, that half-day becomes fifteen minutes to add strategic commentary at the end.

These last two automations need the most infrastructure, but they're also the ones that change team dynamics the most.

9. Conversational knowledge base for customer support. Your support team answers the same questions a thousand times because the official documentation is buried somewhere. A `/answer-support` skill indexes all internal documentation (Notion, Drive, markdown files, product FAQ) and lets agents query it in natural language. The skill returns answers with the exact citation of the source document, so agents verify before sending to the customer. Implementation time: 6-10 hours (most of it is organizing the documentation). Monthly savings: 12-25 hours.

This automation has a side benefit: it forces the documentation to be organized. Many clients tell us the project's biggest value was precisely that, not the chatbot itself.

10. Automated new employee onboarding. When a contract is signed, a `/employee-onboarding` skill executes the entire admin sequence: creates Google Workspace accounts, adds to the department's Slack channel, sends the welcome pack by email, books initial training in Calendar, creates Jira or Linear tickets for equipment delivery, generates access credentials for internal tools, and notifies the manager with the day-one checklist. Implementation time: 5-8 hours. Monthly savings: 3-6 hours (depends on hiring volume).

Onboarding frequency in an SMB may be low, but the cost of bad onboarding is high: the new employee loses two days of productivity waiting for access. Automating this is one of the best uses of Claude Code precisely because it guarantees no step gets forgotten.

This is the realistic sum of monthly time freed for an SMB implementing all 10 automations, assuming average activity volume.

What these numbers say. A week of implementation (38-59 hours, usually split between two people) frees between 69 and 141 hours per month, recurring. If you value an internal hour at €30, that's €2,000-€4,200 per month recovered, against a cost of €20-€200 per month for Claude Code plus API. The return pays back in the first week.

What these numbers don't include. The less tangible and more important benefit: your team stops doing the tasks they hate (triaging emails, copying data between systems, writing the fifth report similar to the fourth) and focuses on the ones that add real value (decision, judgment, customer relationships). That doesn't show up in the table, but it's what keeps people at the company.

1. Trying to automate everything at once. The biggest mistake is disproportionate ambition in week one. Implement one automation per day, let it settle, test with real data, adjust. Wanting all 10 ready by Friday is the recipe for none of them working well and abandoning in week two.

2. Skipping the human review phase. The first 20-50 executions of each skill should be reviewed manually before they trigger irreversible actions (sending email, recording payment, creating account). Once the success rate is stable, switch to autonomous mode. Skipping this is the fastest way to send a weird email to 200 clients on day one.

3. Starting with the most complicated automation. If your goal is to test Claude Code, don't start with the complex marketing report (day 5). Start with email triage (day 1). A quick win on day one convinces the team. A week without results convinces the team this doesn't work.

4. Forgetting to document business decisions. Skills are plain text, but the rules they encode (what's urgent, when to auto-approve, what tone to use) are business decisions. Document them inside each skill. Six months from now when someone asks "why did the skill answer that way," the answer should be in the file, not in the head of whoever wrote it.

5. Using the most expensive model for everything. Claude Code lets you pick between Haiku (cheap, fast), Sonnet (balanced), and Opus (premium). For triage and classification, Haiku suffices. For content drafting, Sonnet. Only critical flows justify Opus. Using Opus for everything multiplies cost by 5x without improving results on most tasks.

6. Believing the work ends after week one. Skills are maintained and improved. The next week you review what failed, adjust the rules, add exceptions. A living skill at six months is 3-5 times better than day one. A dead skill stops working when something changes in your operation.