How a Company in Zurich Saved Over 18 Hours Weekly Reconciling Transactions Manually Using Make

Manual transaction reconciliation can drain significant operational hours and introduce costly errors — a challenge faced by many companies worldwide.  In this case study, we explore how a company in Zurich solved a problem where they spent more than 18 hours per week reconciling transactions manually using Make. You will gain insights into the company’s inefficient initial workflows, how RestFlow approached their business process automation, and a step-by-step walkthrough of the resulting integration leveraging Make, Google Sheets, Slack, and their ERP system.

Whether you are a startup CTO, operations specialist, or automation engineer interested in building robust workflows, this article delivers practical instructions and real-world examples. Learn how to reduce manual labor, minimize errors, and improve financial team efficiency with automation-as-a-service.

The Problem: Manual Transaction Reconciliation Dragging Operations Down

The client is a mid-sized financial services company headquartered in Zurich, Switzerland. Their accounting department was responsible for handling a high volume of daily transaction records — incoming payments, refunds, and chargebacks — across multiple systems.

Before automation, the team reconciled transactions manually by cross-referencing bank statements, payment processor reports, and internal ERP entries using Google Sheets. This painstaking process took more than 18 hours every week, involving:

• Downloading multiple CSV reports
• Manual copy-pasting and comparing rows in spreadsheets
• Identifying discrepancies and investigating errors
• Sending follow-up emails for unresolved items

The pain points were clear:

• Time wasted: Valuable finance team hours lost weekly just on data processing.
• High error rates: Manual work led to frequent mislabeling and missing transactions.
• Lack of real-time visibility: Reconciliation was done in batches weekly, delaying financial reporting.
• Impact on SLAs: Delays affected vendor payment cycles and customer satisfaction.

This inefficiency constrained the company’s ability to scale and reduced overall financial accuracy, prompting a search for a reliable automation solution.

Our Approach: RestFlow’s Automation-as-a-Service Proposal

RestFlow began with a detailed discovery workshop involving the client’s accounting and IT teams. We mapped out the current manual process, identifying key systems involved:

• Banking transaction reports (CSV downloads from online portal)
• Payment processor API (for real-time transaction data)
• Internal ERP system (Microsoft Dynamics 365)
• Team communication (Slack and Gmail)
• Data staging and analysis platform (Google Sheets)

Based on this understanding, we recommended automating the reconciliation process end-to-end using Make as the orchestration tool. Make was selected due to its strong support for spreadsheet and API integrations, flexible scheduling, and error handling.

We designed a high-level architecture where Make flows would:

• Automatically fetch daily transaction data from banking and payment processor systems
• Compare and reconcile records against ERP sales data
• Flag and notify discrepancies through Slack and email
• Update Google Sheets dynamically for reporting and audit trails
• Provide dashboards for real-time financial visibility

This approach promised to save hours of manual work each week, improve accuracy, and speed up reconciliation cycles dramatically.

If you want to start building workflows like this yourself, Explore the Automation Template Marketplace to find ready-made automation building blocks.

The Solution: Architecture and Workflow

Global Architecture Overview

The automated reconciliation system consists of the following components:

• Trigger: A Make schedule triggers the workflow each day at 7AM CET.
• Data Retrieval: The flow fetches the previous day’s banking transactions CSV files (via secure FTP) and calls payment processor REST APIs to pull transaction data.
• Data Staging: Imported data is loaded into dedicated Google Sheets for processing and cross-checking.
• Orchestration: Make runs logic steps to compare transactions with Microsoft Dynamics 365 ERP sales records accessed via API.
• Decision Logic: Records are matched or flagged for discrepancies using conditional branching.
• Notifications: Discrepancies trigger Slack messages to the finance ops team and emails to workflow owners.
• Outputs: Automatically updated Google Sheets serve as dashboards, reporting reconciliation status and audit logs.

End-to-End Workflow Walkthrough

1. Scheduler trigger fires every morning via Make built-in scheduler.
2. FTP module downloads bank statement CSV files from secured banking server.
3. HTTP module authenticates and calls payment processor API (e.g., Stripe) to retrieve latest transaction reports.
4. Google Sheets module imports bank and payment data into separate sheets.
5. HTTP module queries ERP system API for recorded transactions from previous day.
6. Data transformation steps using built-in functions to normalize date formats, currency values, and transaction IDs.
7. Conditional routers in Make match transactions across sources; unmatched items branch to discrepancy handling.
8. Slack module sends detailed messages to finance team channels highlighting suspicious or missing records.
9. Gmail module sends automated emails to responsible account managers when manual intervention is required.
10. Google Sheets module updates reconciliation status dashboard in real-time.
11. Flow ends after logging results to an audit sheet.

Step-by-Step Node Breakdown 

1. Scheduler Trigger (Cron Node)

This node activates the workflow every weekday at 07:00 CET. It ensures that reconciliation starts at the beginning of the financial day, allowing same-day issue resolution.

2. FTP Download (Bank Statement CSV)

Configures connection to the bank’s secure FTP server with credentials stored securely in Make’s secrets manager. Automatically downloads the latest transaction CSV files to a temporary storage step.

3. REST API Call to Payment Processor

Uses Make’s HTTP module to authenticate using OAuth 2.0 with the payment processor (e.g., Stripe). The endpoint /v1/charges returns all transactions from the last 24 hours in JSON format.

4. Google Sheets Import

The flow writes the bank and payment processor data into separate Google Sheets tabs using the “Add Row” and “Update Spreadsheet” actions, preserving source data for audit and processing.

5. ERP API Query

The workflow fetches sales data from Microsoft Dynamics 365 REST endpoints filtered by date. This step uses API key authorization secured in Make settings.

6. Data Normalization and Matching Logic

Using built-in Make tools and formula functions, dates, amounts, and reference IDs are normalized. The workflow matches transactions between sources using unique identifiers (e.g., transaction ID) and amount tolerances.

7. Conditional Routers for Discrepancies 

If a transaction appears in one system but not the others, the router directs the flow to a notification branch; otherwise, it proceeds to confirmation nodes.

8. Slack Notifications

Make’s Slack integration posts detailed alerts to the #finance-alerts channel, including transaction ID, issue type, and links to relevant CRM or ERP records for quick investigation.

9. Automated Email Alerts

Triggered when high-priority mismatches occur, emails with subject lines like “Urgent: Transaction Reconciliation Issue” are sent to designated finance team members with CSV summaries attached.

10. Google Sheets Dashboard Update

This step updates a summary sheet showing reconciliation status metrics like total transactions processed, matched, and exceptions, refreshed after each run.

11. Audit Logging

All processed transactions and actions are logged with timestamps in an audit sheet that can be exported or reported monthly.

Error Handling, Robustness & Security

Error Handling & Retries

The Make workflow design includes automatic retries with exponential backoff on API failures. If a node fails more than 3 times, an error message is sent via Slack to admins.

Logging and Observability

Each run generates detailed logs captured in Google Sheets and Make’s run history. Key metrics like failures, matched counts, and duration are monitored.

Alerting

Slack alerts and email notifications ensure immediate attention to failures or discrepancies, reducing issue resolution time significantly.

Idempotency and Deduplication

The workflow cross-checks transaction IDs against the audit sheet before processing to avoid duplicate handling, ensuring idempotent execution even on retries.

Security & Data Protection

API credentials are stored encrypted within Make and accessible only by authorized administrators. Least-privilege principles apply: API keys have minimal scopes, and personal data access is strictly controlled. All data transmissions use HTTPS, and sensitive files are stored temporarily and deleted post-processing.

Performance, Scaling & Extensibility

The automation scales to handle growing transaction volumes through:

• Batch processing with pagination on API calls
• Queued job handling for asynchronous discrepancy resolution
• Parallelization capabilities in Make for multi-threaded processing
• Ability to add new payment processors or banking sources as webhook integrations
• Modular workflows that can be cloned and customized for regional teams or other finance processes

Using webhooks where supported reduces polling inefficiencies. RestFlow’s managed hosting environment ensures stable performance even as business demands increase.

Comparison Tables

Automation Platform	Cost	Pros	Cons
Make	Starts at $12/month	Powerful visual builder, excellent API and spreadsheet support, granular error handling, cost-effective for moderate volume	Learning curve for complex conditional logic in large workflows
n8n	Free self-hosted, cloud plans from $20/month	Open-source, customizable, flexible with custom code, great community support	Requires hosting setup, less polished UI compared to Make
Zapier	From $19.99/month	Widely adopted, vast app integrations, easy for simple triggers	Limited complexity for branching, higher cost for heavy usage

Integration Method	Latency	Resource Usage	Use Case Suitability
Webhook	Near real-time	Low, event-driven	Best for immediate updates, high scalability
Polling Scheduler	Delayed by schedule interval	Higher, constant requests	Used when no webhook support; simpler setup

Data Storage	Cost	Ease of Use	Scalability	Use Cases
Google Sheets	Free up to limits	Very user-friendly for non-technical users	Limited for very large datasets	Reporting, lightweight data staging, audit logs
Cloud SQL Database	Variable, pay-as-you-go	Requires technical setup	Highly scalable for processing large volumes	Enterprise-grade reconciliation, complex querying

Results & Business Impact

The automated solution delivered transformative results:

• Time saved: Over 18 manual hours per week were eliminated, allowing accounting staff to focus on higher value tasks.
• Error reduction: Transaction mismatches dropped by over 75% due to automated validation and real-time alerts.
• Reporting speed: Reconciliation cycle shrank from weekly batch jobs to daily near-real-time runs, improving SLA compliance.
• Visibility: Google Sheets dashboards gave management instant status updates on transaction health and outstanding issues.
• Team satisfaction: The finance team reported lower stress and greater trust in financial data accuracy.

Overall, the client’s operational efficiency and data integrity improved markedly, supporting better financial decisions and faster response to discrepancies.

Ready to accelerate your finance automation? Create Your Free RestFlow Account and get started today.

Pilot Phase & Ongoing Maintenance Disclaimer

Like any complex automation, the project included an initial pilot phase where the workflow ran with controlled, real transaction data to validate accuracy and adjust handling of edge cases. Minor bugs and process tweaks were identified and resolved during this phase to ensure production readiness.

After the pilot, RestFlow manages ongoing hosting, monitoring, maintenance, and updates—providing a reliable automation-as-a-service environment tailored to evolving business needs. This continuous support ensures the solution remains stable, secure, and scalable as volumes or processes change over time.

Conclusion

In summary, the Zurich financial services company successfully transformed a labor-intensive, error-prone manual transaction reconciliation into a streamlined automated process using Make. By leveraging scheduler triggers, secure API integrations, Google Sheets dashboards, Slack notifications, and email alerts, RestFlow’s automation-as-a-service solution delivered immediate time savings of over 18 hours per week and a significant uplift in data accuracy and reporting speed.

This case study highlights how a well-crafted Make workflow can integrate multiple disparate systems and strengthen financial operations at scale, improving team productivity and enabling faster business decisions.

RestFlow remains the client’s trusted partner by providing end-to-end services covering automation design, implementation, hosting, monitoring, and maintenance — ensuring the solution evolves safely with their needs.

To empower your own finance or operations teams with similar digital transformation, don't hesitate to explore automation templates or create your free RestFlow account and start building powerful workflows today.