Farm to Feed: Streamlining B2B Produce Supply Chains with Serverless AI and Intelligent Document Processing on AWS

Overview

Farm to Feed is a pioneering agricultural logistics and marketplace platform that streamlines the B2B produce supply chain, connecting smallholder farmers with commercial customers like restaurants and hotels. Facing significant operational bottlenecks from manual order intake, Farm to Feed partnered with CloudPlexo to architect a unified, intelligent order automation ecosystem on AWS. By combining a serverless natural language WhatsApp chatbot with an automated Local Purchase Order (LPO) parsing pipeline, the solution transforms unstructured text and varied PDF documents into structured, accurate digital orders. Powered by Amazon Bedrock, Amazon Textract, and AWS Lambda, this intelligent architecture eliminates manual data entry, guarantees product matching accuracy, and seamlessly integrates directly into Farm to Feed’s core ERP system.

"This wasn't a vendor handing us a solution — it was a genuine engineering partnership. We came to CloudPlexo with a hard problem: messy WhatsApp orders, regional product names, inconsistent LPO formats, and edge cases that break naive matching logic. Together we built a system that thinks in context rather than keywords, and that architecture decision is what made it production-ready for our clients. It's the kind of solution you only get when both sides are solving the problem, not just implementing a spec."

• Brian Ababu, Farm to Feed

Business Challenges

• Fragmented, Unstructured Ingestion Channels: Farm to Feed's B2B clients submit orders via two distinct, highly unpredictable streams: informal, natural language messages on WhatsApp (e.g., quantities and item names written in everyday shorthand), and diverse, unstandardized LPO PDF formats requiring manual extraction.
• The Semantic Matching Gap: Traditional keyword-matching algorithms failed miserably against real-world ordering vernacular. Casual product terms, regional names, plurals, and partial descriptions caused frequent misidentifications, matching simple,commonly ordered items to wrong database SKUs.
• Client Onboarding Friction: B2B customers frequently grew frustrated when forced to repeatedly clarify specific product preferences (e.g., confirming that a generic item request mapped to a particular varietal or specification).
• Pipeline Blind Spots and Data Mismatches: Slight data discrepancies in the PostgreSQL database— such as inconsistent capitalization in status fields—caused items to silently drop from matching routines, leading to lost sales and invisible data failures.

Solution: Implementation of Intelligent Order Automation with CloudPlexo

CloudPlexo and Farm to Feed jointly deployed a dual-engine automation framework built entirely on AWS Serverless architecture using the AWS SAM (Serverless Application Model) framework. Farm to Feed’s engineering team worked alongside CloudPlexo throughout, defining requirements, shaping the matching logic around real catalog and ordering behavior and leading the ERP integration and rollout. This infrastructure decouples traffic, automates document parsing, and runs an intelligent multi-stage semantic matching layer.

1. Conversational Commerce via WhatsApp Bot

When a client sends an order over WhatsApp, Twilio forwards the request via API Gateway to a Twilio Validator Lambda. This function verifies the request signature and instantly offloads the raw message into Amazon SQS. This asynchronous queue decouples the entry point from the application logic, safely absorbing spikes in traffic.
A downstream Main Bot Lambda processes the queue, routing the message through a modular architecture:

• The Brain (order_llm.py): Uses Amazon Bedrock (Claude) to parse erratic natural language into a highly structured JSON array of products and quantities.
• The Logic (order_flows.py): Drives a conversational state machine, supporting multi-order routing (e.g., parsing separate orders for different delivery locations within a single block of text) and generating interactive "Confirm or Edit" flows.

2. Intelligent Document Processing (LPO Parser)

For corporate clients utilizing formal purchasing routes, PDFs are uploaded to an Amazon S3 LPO Repository. This action immediately fires an Orchestration Lambda, which calls Amazon Textract to structurally isolate raw document keys, tables, and text values.
The extracted data payload passes to a secondary mapping Lambda that checks details against a PostgreSQL instance containing client-specific parsing parameters. An LLM-backed fuzzy matcher bridges the gap when processing unfamiliar formats or new line items, seamlessly resolving layout deviations without manual template configurations.

3. Multi-Stage Product Matching Engine

To defeat the common edge-case errors that disrupt standard search engines, CloudPlexo and Farm to Feed built a rigorous, multi-stage matching engine in code:

• Alias Mapping: Converts regional or vernacular terminology instantly into standard catalog names
• Token Containment & Word Count Checks: Resolves cases where a specific varietal request (e.g., a named sub-type of a common vegetable) could be blindly matched to its broader parent category. The engine verifies word boundaries and counts, isolating and disqualifying the broader category.
• Prefix Priority & Bloat Filters: Tackles cases where a single-word query risks matching an unrelated compound product that happens to share that word. The engine enforces a strict prefix check, prioritizing genuine variants of the requested item while automatically discarding distracting compound phrases and unrelated cross-category matches.

4. Continuous Learning & Architectural Resilience

• User Preference Memory: To avoid repeating past alignment prompts, the bot tracks corrections in an Amazon DynamoDB UserPreferencesTable.Once a client confirms a preferred variant or specification for a given item, DynamoDB seals that preference, applying it silently to all future orders.
• Custom Data Serialization: To address serialization limits within state logs, a custom DecimalEncoder handles precise numeric weights (such as 0.5 kg measurements) seamlessly inside DynamoDB.
• Isolated Secrets Management: No database credentials or third-party enterprise tokens are exposed in code or environment configurations; all access strings are dynamically requested from AWS Secrets Manager, protecting the internal ERP endpoints.

Results

• Substantial Reduction in Data Re-Keying: Both natural language text messages and complex LPO documents are now parsed and translated electronically, creating automated draft orders inside the ERP system instantly.
• Near-Elimination of Catalog Mismatch Errors: The multi-stage matching logic has dramatically reduced catalog mismatch errors of the kind that previously caused misidentified line items, validating orders with far greater precision.
• Seamless Client Personalization: By storing learned behavioral preferences in DynamoDB, the platform remembers unique ordering habits, cutting down conversational clarification loops and enhancing B2B customer satisfaction.
• Forensic Observability: By introducing granular, high-fidelity logging strings inside Amazon CloudWatch (including targeted keyword filters like "DEBUG SPY", "Bloat Filter", and "Alias Match"), engineering teams can spot database status issues or inventory sync failures in real-time.

Operational Cost Savings

Adopting a completely serverless layout through AWS SAM drastically reduced operational infrastructure costs. By substituting always-on compute instances with AWS Lambda, Amazon SQS, and pay-per-request Amazon Bedrock invocations, infrastructure costs scale perfectly with sales activity. Farm to Feed pays only for active computing runtime during order parsing and message routing. This serverless approach eliminates idle resource waste during off-peak hours and lowers development overhead through hands-free, automated service maintenance.

Conclusion

By collaborating with CloudPlexo to deploy an intelligent, serverless ingestion system on AWS, Farm to Feed successfully transformed its complex, manual order fulfillment workflow into a highly automated, scalable engine. The combination of Amazon Bedrock’s contextual parsing and a customized, multi-stage matching engine gives Farm to Feed the unique ability to handle unstructured data channels with precision. This successful digital transformation eliminates operational administrative strain, minimizes warehouse picking errors, and provides a scalable foundation to onboard corporate clients efficiently.