File-based integrations are everywhere.
ERP systems exporting data. Cameras uploading footage. Legacy systems pushing CSV files. Partners exchanging documents.
And despite all the talk about APIs and real-time systems, a surprising amount of real-world infrastructure still runs on one simple thing:
File transfers.
The problem isn’t FTP. It’s everything around it.
The missing layer
Traditional FTP setups are good at one thing:
Moving files from A to B.
But modern systems need more:
- Events when something happens
- Programmatic access to data
- Integration with other systems
- Visibility and control
Without that, teams end up building:
- Cron jobs polling directories
- Scripts parsing file systems
- Fragile integrations
We kept seeing the same pattern again and again:
Things work — until they don’t.
From file transfer to event-driven workflows
What if file transfers weren’t passive?
What if:
- A file upload triggered an event
- That event called another system
- And the data could be accessed via API
That’s the shift from “FTP server” → “integration layer”.
The model: FTP + webhooks + API
We’ve been working on combining three simple building blocks:
- FTP for ingestion
- Webhooks for events
- API for structured access
Individually, these are nothing new.
Together, they unlock something much more powerful.
Real-world example 1: ERP → customer system
Let’s say you need to share data from your ERP system with an external partner — for example an auditor, a customer, or a BI tool like Tableau. You don’t want to give direct access to your ERP, but you still need a secure and automated way to deliver data they can consume.
A common integration flow:
- ERP exports a file
- File is uploaded via FTP
- A webhook is triggered
- Customer system receives the event
- Data is fetched via API
ERP → FTP → Webhook → Customer system → API
No polling. No custom parsing. No glue scripts everywhere.
Real-world example 2: Video surveillance alerts
A very real use case could be a surveillance setup where cameras continuously upload footage, but you only care when something actually happens. You don’t want someone watching feeds all day — you need instant alerts when motion is detected.
Another scenario:
- Camera uploads a video file
- File lands via FTP
- Webhook triggers instantly
- Notification system sends SMS/email
Camera → FTP → Webhook → Notification
Result:
- Real-time alerts
- No constant monitoring
- Simple integration
Real-world example 3: Smarter backups
Many teams rely on scheduled backups, but have experienced silent failures at some point — files are uploaded, but no one really knows if they’re valid or complete.
Backups are usually passive.
But they don’t have to be.
- Backup file is uploaded
- Webhook triggers validation
- API checks file size / existence
- Alert if something is wrong
System → FTP → Webhook → Validation → API
This turns “hope it worked” into something observable.
Real-world example 4: FTP + S3 pipelines
In more advanced setups, you might receive files from external systems, while your processing and analytics live in the cloud — for example on AWS.
You need a simple ingestion point, but also scalable storage and processing.
- Files uploaded via FTP
- Synced to S3
- Webhook triggers processing
- Data flows into pipelines
FTP → S3 → Webhook → Processing
This combines:
- Simplicity (FTP)
- Scalability (S3)
- Automation (events + API)
Why this approach works
Because it separates concerns:
- FTP = ingestion
- Webhooks = events
- API = access
Instead of forcing everything into one system, each part does what it’s best at.
What we’re building
We’ve been working on a cloud-based FTP platform with built-in webhooks, and we’re currently adding a REST API layer. Scheduled for production release end of May 2026.
The goal is simple:
Make file-based workflows programmable.
Instead of treating FTP as a dead end, it becomes part of a modern integration stack.
Final thought
FTP isn’t going away.
But how we use it is changing.
And for many teams, the real opportunity isn’t replacing FTP —
it’s turning it into something that actually fits modern infrastructure.
If you're curious, we've been documenting some of these patterns here: