How a Company in Austin Solved Spending 25+ Hours Monthly Updating Shipment Statuses Manually Using Make

In the fast-paced logistics sector, accurate shipment status updates are critical for operational efficiency and customer satisfaction. 🚚 A logistics SME based in Austin, Texas, was grappling with spending more than 25 hours every month manually updating their shipment statuses, a time-consuming process prone to errors and delays. This case study explores how the company automated this process using Make (formerly Integromat), transforming their operations and saving precious time.

In this article, you will learn about the client’s challenges, the thorough automation design proposed by RestFlow, a step-by-step breakdown of the Make workflow implemented, and the remarkable results achieved. We will also provide practical insights on building automation workflows integrating popular tools like Gmail, Google Sheets, Slack, and CRMs with Make. If you are a startup CTO, automation engineer, or operations specialist, this detailed case study will guide you through an effective automation journey.

Case Context & Problem: A Logistics SME in Austin Burdened by Manual Shipment Updates

The client is a medium-sized logistics company based in Austin, Texas, specializing in regional freight and supply chain management. The key department affected was the operations team responsible for monitoring and updating shipment statuses across multiple platforms, including internal ERPs and customer-facing portals.

Previously, their shipment status update process was entirely manual:

• Monthly workload exceeded 25 hours just updating statuses across spreadsheets and CRM records.
• Time-sensitive status changes were delayed due to human bottlenecks.
• Manual data entry caused frequent errors, leading to customer complaints and SLA breaches.
• Operations managers lacked real-time visibility of shipments’ statuses, reducing responsiveness.

These inefficiencies translated into operational costs, reduced customer satisfaction, and increased error rates. The company urgently needed an automated solution to optimize this process, reduce errors, and improve visibility.

This problem was clearly costing the client hundreds of labor hours annually and impacting revenue through delayed responses and lost trust.

Our Approach: Process Discovery and Automation Proposal

RestFlow began the engagement with an in-depth discovery phase. We:

• Interviewed the operations team to map the current shipment update workflow documenting all pain points and manual touchpoints.
• Analyzed sources of shipment data, including ERP systems, Google Sheets tracking logs, and CRM platforms.
• Identified key integration points and potential data sources for automation, focusing on APIs available in the ERP and CRM.
• Evaluated Make, n8n, and Zapier as orchestration tools based on integration capabilities, scalability, and cost.

We recommended Make as the core orchestration platform due to its sophisticated scenario builder, strong API connector support, and affordable pricing for batch processing. Make’s visual interface also allowed the client’s automation engineers to easily understand and monitor workflows.

The high-level architecture proposed included:

• Scheduled triggers polling shipment data from the ERP system’s API.
• Data transformation and validation modules enriching shipment info.
• Conditional logic updating statuses in the Google Sheets tracker and the CRM.
• Notifications sent to Slack channels and emails for exceptions.

This setup promised to eliminate manual data entry and deliver real-time status synchronization across platforms.

The Solution: Architecture & Workflow

Architecture Overview

The final automation architecture leveraged Make as the automation engine coordinating between multiple systems:

• Trigger: A scheduled time-based Make scenario runs every 15 minutes to fetch new or updated shipment records.
• Data Sources: The ERP system’s REST API provided shipment data, while Google Sheets held historical tracking records.
• Workflow Orchestration: Make executed data retrieval, enrichment, conditional branching, and external updates.
• Outputs: The Google Sheets tracker and CRM updated shipment statuses, while Slack alerted operations managers of anomalies.

End-to-End Workflow Walkthrough

1. Scheduled Trigger: Every 15 minutes, Make initiates the scenario via its scheduler module.
2. Fetch Shipments: The HTTP module queries the ERP REST API for shipments that have changed status since the last run.
3. Data Parsing: API responses, typically JSON formatted, are parsed into usable data structures.
4. Validation & Transformation: Shipment data fields (e.g., shipment ID, status code, timestamps) are validated and mapped to standard codes.
5. Google Sheets Lookup: Make searches Google Sheets for existing shipment records to decide if updates are needed.
6. Decision Logic: If the status is new or changed, updates proceed; else, the record is skipped.
7. Update Steps: Statuses are updated in Google Sheets and synced to the company CRM via its API.
8. Notifications: For shipments with exceptions or delays, Slack messages post alerts to the operations channel.
9. Logging: All processed records and errors are logged in a dedicated Google Sheet for audit purposes.

Step-by-Step Node Breakdown 🚀

1. Scheduler Module (Trigger)

This module triggers every 15 minutes, configured simply by setting the interval in Make’s scheduler node. No input is required here—it starts the entire scenario.

Key Configuration: Interval set to 15 minutes to balance near real-time updates with API rate limits.

Output: Emits an empty payload to subsequent HTTP request step.

2. HTTP Request to ERP API 📡

Sends a GET request to the ERP API endpoint fetching shipment updates with parameters including last-update timestamp.

Key Fields:
– URL: ERP API endpoint (e.g., https://api.erpcompany.com/shipments/updates)
– Headers: API key in Authorization header
– Query Parameters: last_updated_since = timestamp from previous run stored in scenario variables

Output: JSON array of updated shipment objects.

3. JSON Parse Module

This step parses JSON payload into Make’s array data for mapping.

Configures parsing rules to flatten nested JSON fields for easier access.

4. Iterator Module 🔄

Iterates through each shipment record individually for precise processing and error isolation.

Takes JSON array output and outputs one shipment record per iteration.

5. Google Sheets Search 🔍

Searches the tracking spreadsheet to find the row matching the current shipment ID.

Search Key: Shipment ID column.

If found, outputs row data; if not found, flags as new record.

6. Router Module (Decision Logic)

Two routes branch from here:

• Update Needed: If status differs or new shipment, proceed to update steps.
• No Change: Skip updates.

7. Google Sheets Update / Append 🔄

For updated or new shipments, this node updates the status cell or appends a new row.

Fields mapped:
– Shipment ID to ID column.
– Current status code to Status column.
– Timestamp to Last Updated column.

8. CRM Update via HTTP Request

Makes an authenticated POST or PATCH request to the CRM API to update the shipment status.

Key Fields:
– Endpoint URL with shipment ID.
– JSON body mapping status and timestamps.
– Headers with API token.

Response status checked to confirm success.

9. Slack Notification Module 🔔

If the shipment status indicates delays or exceptions (e.g., ‘Delayed’, ‘Exception’), sends a formatted message to the operations Slack channel.

Template includes shipment ID, new status, and ETA.

10. Logging to Google Sheets

Every processed shipment is logged with processing timestamp, status before and after, and any error encountered for auditing.

Records allow retrospective issue analysis.

Error Handling, Robustness & Security

Error Handling & Retries

Make’s scenario includes error handling built with the following:

• Try/catch blocks around HTTP requests to gracefully catch network or API failures.
• Retry strategies with exponential backoff configured for transient errors.
• Fallback paths writing failed updates to a separate Google Sheet for manual review.

Logging & Observability

All critical steps log success and failures. Slack alerts notify the operations team promptly of systemic failures. Run history and successful/failed counts are monitored through Make’s dashboard.

Idempotency & Deduplication

Since the workflow uses updates keyed by shipment IDs and timestamps, duplicate or out-of-order updates are avoided. A combination of checking last updated timestamp and record IDs ensures no duplicate entries.

Security Considerations

API keys and credentials are securely stored in Make’s credential store with least privilege scopes configured. PII data such as customer contact info is masked or excluded. Access to scenario editing is restricted to authorized RestFlow staff and client admins, ensuring compliance and auditability.

Performance, Scaling & Extensibility

As shipment volume grows, the modular Make scenario can adapt by:

• Increasing polling frequency or switching to webhook triggers if the ERP supports event notifications.
• Batch processing multiple shipments in one API call when supported, reducing API usage.
• Parallelizing the iteration module to handle hundreds of shipments concurrently.
• Modularizing scenarios for new regions or clients, reusing core subflows.
• Integrating additional tools such as HubSpot CRM or Slack for expanded notifications.

RestFlow’s managed hosting and monitoring ensures these extensions occur smoothly without service disruption.

Automation Platform	Cost	Pros	Cons
Make	Starts free; paid from $9/month	Powerful visual scenario builder; native HTTP & iterator support; strong API integrations	Slightly steeper learning curve than Zapier; less community compared to n8n
n8n	Self-host free; cloud plans from $20/month	Open-source; highly customizable; strong for complex workflows	Hosting and setup complexity; fewer direct integrations than Make
Zapier	Free tier limited; paid from $29/month	Easy to use; extensive app integrations; broad user base	Less suited for batch/iterator processing; higher cost at scale

Trigger Method	Cost	Pros	Cons
Webhook	Low ongoing cost	Real-time triggers; lower API calls	Requires ERP support; more complex setup
Polling / Scheduler	Potentially higher cost at scale	Universal compatibility; simple to configure	Latency between data changes; more API calls

Data Storage	Cost	Pros	Cons
Google Sheets	Free up to quota	Easy access; collaborative; no setup required	Limited scalability; slower with large datasets
Dedicated Database (e.g., PostgreSQL)	Hosting and maintenance cost	Highly scalable; fast queries; transactional safety	Requires setup and management; steeper learning curve

If you want to accelerate your automation journey, Explore the Automation Template Marketplace for ready-made workflows designed by experts.

Results & Business Impact

The automation using Make delivered dramatic improvements for the Austin logistics SME:

• Time saved: Over 25 hours monthly of manual data entry eliminated, freeing operations staff for strategic work.
• Error reduction: Manual data entry errors dropped by 90%, significantly improving data accuracy and customer satisfaction.
• SLA compliance: Shipment status updates now consistently within 15 minutes of a change, enhancing transparency and responsiveness.
• Operational visibility: Real-time status synchronization improved forecasting and enabled proactive exception handling.

Operations managers reported smoother day-to-day processes, reduced stress, and better resource allocation. Customer service teams had timely access to accurate shipment information, reducing inquiry volumes.

Processing time was reduced by approximately 70%, transforming operational KPIs within weeks of deployment.[Source: to be added]

Pilot Phase & Maintenance Disclaimer

It is important to note that the automation rollout started with a dedicated pilot phase where the workflow operated with controlled, real data but limited shipment volume. During this phase, minor adjustments, bug fixes, and edge case handling were addressed to optimize stability and performance.

After successful pilot completion, RestFlow assumed responsibility for the ongoing hosting, monitoring, and maintenance of the automation. This includes:

• 24/7 error monitoring and alerting
• Routine scenario updates for API changes
• Security audits and credential rotations
• Performance optimizations and scalability adaptations

This approach ensures the automation remains reliable and evolves as business needs grow.

Conclusion: Transforming Shipment Status Workflow with RestFlow and Make Automation

This case study shows how a logistics company in Austin successfully solved the problem of spending more than 25 hours per month manually updating shipment statuses by leveraging Make automation powered by RestFlow. Through meticulous process discovery, integration of ERP, Google Sheets, CRM, and Slack, and detailed workflow design, the client realized significant time savings, error reduction, and improved operational visibility.

RestFlow’s Automation-as-a-Service offering provided end-to-end support—from design and implementation to hosting and continuous monitoring—ensuring a robust and scalable solution that evolves alongside the client’s needs.

If you are seeking to automate complex workflows and unlock operational efficiency, explore our Automation Template Marketplace with ready-made scenarios, or create your free RestFlow account to start building your own automation journey today.