What they thought they needed vs what we proved was possible.

Invoice-to-ERP Pipeline

What they thought they needed:

"Multi-vendor integration platform. Probably 6-month build with a team of 3-4 developers. We're looking at RFPs from enterprise vendors quoting $150k-$250k for setup + $3k/month."

What we proved:

Prototype in 3 weeks, $400/month to run, they deployed it themselves with their existing ops team. Processing 200+ invoices/month within 2 months of handoff.

The insight:

90% of the complexity was just parsing PDFs correctly and handling the edge cases (rotated scans, multi-page invoices, line items spanning pages). The "integration" was a simple webhook to their ERP. They didn't need a platform — they needed reliable extraction with exception handling.

Technical details:

• Stack: Python/FastAPI, Claude 3.5 Sonnet API, PostgreSQL, Redis queue, Docker
• Cost: $12k prototype development, ~$400/mo operational (API usage + hosting)
• Timeline: 3 weeks from kickoff to handoff, 2 weeks for their team to deploy to production
• Outcome: Processing 200+ invoices/month, saving 15-20 hours/week of manual data entry
• Accuracy: 95%+ field-level accuracy, human review queue for edge cases

What they built in-house vs bought:

• Built: Core extraction logic, validation rules, exception routing, ERP webhook integration
• Bought: Claude API for extraction, AWS for hosting, existing ERP system (already had)
• Skipped: Enterprise OCR platform ($$$), custom ML model training, vendor lock-in

What made this work:

• They had 50+ sample invoices from real vendors to test against
• Their ERP already had a webhook API (just needed documentation)
• Their ops team was comfortable reviewing exceptions in a simple web UI
• They didn't need real-time processing — batch runs every 4 hours was fine

Contract Clause Extraction

What they thought they needed:

"AI-powered contract analysis platform. We're reviewing contracts from 20+ vendors and manually extracting key clauses (liability caps, termination terms, renewal windows). Takes our legal team 3-4 hours per contract."

What we proved:

Built a focused extraction tool in 2 weeks. $8k development, $150/month to run. Reduced review time from 3-4 hours to 30 minutes per contract.

The insight:

They didn't need a full "contract lifecycle management" platform with all the bells and whistles. They needed 8 specific data points extracted from each contract, flagged if unusual, and exported to a spreadsheet. Classic case of vendors trying to sell a Ferrari when they needed a bike.

Technical details:

• Stack: Python/FastAPI, GPT-4 API, simple web UI, CSV export
• Cost: $8k prototype, ~$150/mo operational (mostly API costs)
• Timeline: 2 weeks discovery + build, 1 week refinement based on their feedback
• Outcome: Processing 40+ contracts/month, 85% time reduction per contract
• Accuracy: 92% extraction accuracy, legal team reviews all flagged items

What they built in-house vs bought:

• Built: Custom extraction prompts, validation logic, flagging rules, export formatting
• Bought: GPT-4 API, basic hosting, PDF parsing library (open source)
• Skipped: Enterprise CLM platform ($50k/year), custom NLP training, complex workflow engine

Key tradeoff we made:

This tool is single-purpose. It extracts 8 fields from contracts, nothing more. If their needs expand significantly, they might eventually need a real platform. But right now, they're saving 120+ hours/month for $150/mo. ROI in week one.

Email Intake to Support Tickets

What they thought they needed:

"Smart email routing system that categorizes incoming support requests and creates tickets in our system. Vendors quoted $40k-$80k and 4-6 months of integration work."

What we proved:

Prototype in 10 days, $5k total cost, $200/month to run. They extended it themselves after handoff to add more categories.

The insight:

Their ticketing system already had an API. They just needed email parsing, basic categorization, and ticket creation. This was 80% glue code and 20% clever prompting. Not worth $80k or 6 months.

Technical details:

• Stack: Python, Gmail API, Claude API for categorization, Zendesk API
• Cost: $5k development, ~$200/mo operational
• Timeline: 10 days from kickoff to working prototype
• Outcome: Processing 300+ emails/week, 70% routed correctly without human intervention
• Accuracy: 85% correct categorization, escalation queue for uncertain cases

What they built in-house vs bought:

• Built: Email parsing, categorization logic, ticket creation, error handling
• Bought: Claude API, existing Gmail + Zendesk subscriptions (already had)
• Skipped: Enterprise customer service platform, complex workflow builder, ML training

What happened after handoff:

Their team added 3 new categories we didn't include in the prototype, tweaked the routing rules, and added Slack notifications for high-priority items. Took them a week. This is what good handoff documentation enables.

When We Said "Don't Build This"

What they wanted:

"Custom sales pipeline automation that integrates Salesforce, email, calendar, and DocuSign. Auto-follows up with prospects, schedules meetings, sends contracts."

What we recommended:

Don't build this. Use HubSpot or Salesforce's native automation plus Zapier. You'll spend $500/month instead of $50k custom development, and it'll be more maintainable.

Why:

• Complexity: This is workflow automation across 5+ systems, each with complex state
• Maintenance burden: Every vendor API change would break something
• Edge cases: Sales processes have infinite edge cases — you need a flexible tool
• Better options exist: This is exactly what HubSpot/Salesforce are built for

What they paid us:

$2,500 for a 3-day build vs buy assessment. We documented why custom development was the wrong choice, compared 4 vendor options, and gave them a setup guide for HubSpot. They implemented it themselves in 2 weeks and saved ~$45k.

The lesson:

Sometimes the best automation is admitting you shouldn't automate. My job is to tell you the truth, not to maximize billable hours.