The Integration Problem
You found the perfect self-hosted stack. App A stores your data. App B handles your workflow. But there is no plugin, no Zapier trigger, and the only integration option is a $50/mo SaaS connector that routes your data through someone else's servers.
This is the reality for most self-hosted applications. Directus, Plausible, Outline, NocoDB, Ghost — all have solid APIs, but none appear in Zapier's 7,000-app catalog. When you need these apps to talk to each other, you are left writing curl scripts, managing cron jobs, and debugging JSON parsing errors at 2am.
Three Scenarios Where This Hurts
- No plugin exists. Your app is niche, self-hosted, or too new. Zapier, Make, and n8n have no pre-built connector. The API exists but nobody has wrapped it.
- Only the cloud version is supported. The integration platform supports the SaaS version of your app, but you are running self-hosted. The connector does not work with your instance.
- The "integration" costs more than the apps. A third-party connector charges $50-200/mo for what amounts to a webhook relay. You are paying more for the glue than for the tools themselves.
What Are Stacker PIPEs?
A PIPE is a CLI-native data bridge between any two HTTP services. It runs entirely on your infrastructure — the Stacker agent fetches data from a source endpoint, applies field mapping, and delivers it to a target endpoint. Three commands: create, activate, trigger. No SaaS dependency, no per-execution fees, no data leaving your server.
Why PIPEs Over Zapier?
1. Zero Per-Task Cost
Zapier charges per "task" — each data transfer counts. Make charges per "operation." n8n Cloud charges per workflow execution with monthly limits. A moderately busy app processing 10,000 form submissions or webhook events per month can cost $100-500 on these platforms.
Stacker PIPEs run on your own infrastructure with no per-execution fees. The only cost is the server you already pay for. For high-volume integrations, this eliminates the primary cost driver of cloud integration platforms entirely.
2. Data Never Leaves Your Infrastructure
Zapier and Make route all data through their servers. Even n8n's self-hosted option requires their cloud for certain features. Stacker PIPEs execute entirely within your Docker network — the agent fetches from source containers and pushes to target containers using internal IPs. No third party sees your data in transit.
This matters for healthcare, finance, GDPR-regulated workloads, or any scenario where "we don't want our data on someone else's server" is a requirement, not a preference.
3. Works with Internal Docker Network Services
Zapier and Make can only reach publicly accessible APIs. They cannot connect to services running on internal Docker networks — a Directus instance on port 8055 inside a container, a PostgREST endpoint, or a Kong gateway route.
Stacker PIPEs operate at the container level. They reach services by Docker DNS name (plausible:8000, directus:8055) without requiring public exposure. No need to open ports, configure reverse proxies, or generate API keys for external access.
4. Any HTTP Endpoint, No Connector Needed
Zapier has 7,000+ pre-built connectors. If your app is not among them, you cannot integrate it without writing custom code steps. Make has fewer. n8n requires building custom HTTP Request nodes.
Stacker PIPEs work with any HTTP endpoint. You specify the source path (GET /api/v1/stats) and the target path (POST /api/v1/conversations) and it works — regardless of whether the API follows OpenAPI conventions or uses custom routing like Directus at /items/* or Chatwoot at /api/v1/*.
Example: Plausible Analytics to Slack
Plausible is a privacy-first analytics tool with a clean REST API — but no Zapier connector, no Make integration, and no n8n node. If you want to send Plausible pageview data to Slack when a blog post hits a traffic threshold, your options are: write a custom script, or use Stacker PIPEs.
Architecture
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Plausible │ │ Stacker │ │ Slack │
│ Analytics │ │ Agent │ │ Webhook │
└──────┬────────┘ └──────┬──────┘ └──────┬───────┘
│ │ │
│ GET /api/v1/ │ │
│ stats/realtime │ │
│◄───────────────────│ │
│ │ Field mapping │
│ │ ($.results) │
│ │ │
│ │ POST /webhook │
│ │───────────────────►│Three Commands
# 1. Create the pipe
stacker pipe create plausible slack --name "plausible-alerts"
# 2. Activate — tell the agent where to fetch and where to deliver
stacker pipe activate <pipe-id>
# 3. Trigger — fetch data and deliver it
stacker pipe trigger <pipe-id> --data '{"page":"/blog/my-post","visitors":1000}'The agent fetches pageview data from Plausible's API, maps the relevant fields, and POSTs the payload to the Slack webhook. No scripts, no cron jobs, no third-party service seeing your analytics data.
The Trade-offs
Stacker PIPEs are not a drop-in replacement for Zapier. They serve a different audience and solve a different problem. Here is what you give up:
- CLI comfort required. PIPEs are created via command line. There is no browser-based visual editor. If your team is not comfortable with a terminal, this is not the right tool.
- No visual workflow builder. Zapier and Make support multi-step workflows with branching, filtering, delays, and conditional logic. PIPEs are point-to-point: source endpoint, field mapping, target endpoint. No branching, no multi-step chains.
- No pre-built connectors. Every integration requires manual endpoint specification and field mapping. There is no marketplace of shared pipe configurations or community-contributed templates.
- Endpoint discovery is incomplete. The agent's automatic endpoint discovery only finds APIs at standard paths (
/api,/openapi.json). Apps with non-standard paths require manual specification.
When to Use What
| Use Case | Best Tool |
|---|---|
| Non-technical team, simple webhooks between popular SaaS apps | Zapier |
| Visual workflows with branching, delays, and error handling | Make or n8n |
| Self-hosted stack, data privacy requirements, high volume | Stacker PIPEs |
| Internal Docker services that should not be exposed publicly | Stacker PIPEs |
| Apps with no Zapier/Make connector and non-standard APIs | Stacker PIPEs |
Full Comparison
| Dimension | Stacker PIPEs | Zapier | Make | n8n |
|---|---|---|---|---|
| Pricing | Flat (server only) | Per-task | Per-operation | Per-execution (cloud) or free (self-hosted) |
| Data privacy | Your infra | Their servers | Their servers | Self-host option |
| Internal Docker access | Yes | No | No | Yes (self-hosted) |
| Setup | CLI required | Browser | Browser | Browser |
| Visual builder | No | Yes | Yes | Yes |
| Multi-step workflows | No (point-to-point) | Yes | Yes | Yes |
| Custom APIs | Any HTTP | Webhooks only | HTTP module | HTTP Request node |
| Vendor lock-in | Low (standard HTTP) | High | High | Low (OSS) |
Key Takeaways
- PIPEs are the integration layer for teams already self-hosting with Stacker — the audience that has rejected SaaS for deployment should also reject SaaS for integration.
- Zero per-task pricing eliminates the cost surprise of Zapier and Make for high-volume workloads.
- Data never leaves your infrastructure — critical for privacy-sensitive workloads in healthcare, finance, or GDPR-regulated environments.
- Works with any HTTP API, no connector dependency. If the app has an API, PIPEs can connect to it.
Further Reading
- How to Connect Any Two Apps with Stacker PIPEs - Manual Endpoint Guide
- Connect Directus to Any Service with Stacker PIPEs
- Stacker PIPE Execution Deep Dive - Debugging Cross-Container Data Pipelines
For full PIPE documentation, see the Stacker docs.