People build very different things on the same Binions install. Because the building blocks are generic — read a mailbox, call a web API, run a query, move a file, ask an AI, read a sensor — one platform covers jobs as varied as invoicing, SaaS integration, factory-floor monitoring, and home automation. This page walks through the patterns customers reach for most, end to end.
One pattern, many jobs. Every scenario below is the same shape: an event comes in, a playbook decides what to do, and the right daemons carry it out. Once you see the pattern in one domain, you can apply it to the others.
The most common starting point. Binions watches a mailbox, a form, or the clock, then turns each event into a chain of actions — extract, store, notify — without anyone touching a spreadsheet.
- Invoice intake. An invoice lands in a shared mailbox. Binions reads it, an AI step extracts the supplier, amount, and due date, the figures are written to a database, the original PDF is filed in object storage, and your finance channel gets a notification — all hands-off.
- Web-form & CRM intake. A contact form or CRM webhook fires. The submission is validated, saved to a database, and posted to Slack so a salesperson can follow up fast.
- Scheduled reports. On a cron-style schedule, Binions runs a database query, has an AI step write a short summary, and emails the digest to whoever needs it — every morning, no reminders.
- Multi-channel notifications. One event fans out to several places at once: an email, a Slack message, and an MQTT signal to an on-site display.
- Document pipelines. Parse incoming documents or newsletters, pull out the parts that matter with AI, and store the structured result in a database for searching later.
Binions connects the SaaS tools and internal services you already use. Instead of a separate connector for every app, it uses one generic action — “send a webhook” — that can talk to any service with a REST API, plus inbound HTTP routes that let other apps call you.
- Outbound to any REST API. A single webhook step reaches Slack, GitHub, Stripe, Notion, HubSpot, Zendesk, and hundreds of other tools. You describe each integration in a short playbook rather than waiting for a vendor to ship a connector.
- Inbound webhooks. Register an HTTP route and let an external app trigger a playbook — a payment provider, a form builder, or a CI system can push events straight into your workflows.
- Glue between internal services. Stitch your own services together: one system’s output becomes another’s input, with Binions in the middle handling retries and logging.
Good to know. Tools that use a simple token or API key work right away. A few popular services — Google Workspace and Microsoft 365 — use interactive OAuth2 sign-in, which Binions reaches by composing a couple of playbook steps rather than a one-click toggle. See Integrations for the details.
This is where Binions stands apart from typical automation tools. It speaks MODBUS (TCP and RTU-over-TCP) natively, so factory hardware joins the same automations as your email and APIs — and it’s small enough to run on a Raspberry Pi* right next to the machine.
- Data collection from PLCs. Poll programmable controllers every second for temperature, pressure, or vibration, and stream the readings into a database for trends and dashboards.
- Act on a threshold. When a sensor crosses a limit, Binions writes back to the controller — stopping a line or switching a relay — and records the event in an audit log.
- Binions as a MODBUS slave. Run Binions in server mode so an upstream SCADA system can read aggregated line state directly from it, bridging your automations into existing plant software.
- MQTT sensor bridging. Bring MQTT sensors and smart devices into your playbooks, so a reading from the field can trigger any action Binions supports.
- Edge deployment. The whole stack runs locally at the machine — no cloud round-trip, no per-task billing — and keeps working when the wider network drops.
The same event-to-action engine makes a capable, lightweight security helper — routing alerts, verifying signatures, and keeping a trustworthy record of what happened.
- SIEM-lite alert routing. Alerts from monitoring tools become events; a playbook correlates them and forwards what matters to a Slack channel or a ticket, so the right people see it quickly.
- Signed-webhook verification. Incoming webhooks are checked with HMAC signatures (the same approach providers like Stripe use), so only genuine events trigger your workflows.
- Audit trails. Every action is recorded to an append-only log, giving you a clear, tamper-evident history of who did what and when.
Because it’s tiny and scriptable, Binions works as a lightweight alternative to heavyweight home-automation hubs — happily running on a Raspberry Pi* in the corner.
- Lightweight home automation. An MQTT message from a sensor triggers an action — open a gate, switch lights, send a phone notification — all defined in a short, readable playbook.
- Personal digests. Pull in a feed, have AI summarise it, and send yourself a tidy daily digest by email or chat.
- Runs on a Raspberry Pi*. The full platform fits comfortably on small hardware, so a hobby project doesn’t need a server.
Proven end to end. The flagship example is the invoice pipeline: an email arrives, AI extracts the figures, the data is written to a database, the PDF is stored in object storage, and the team is notified — a complete, real workflow that ties together email, AI, storage, and messaging in one playbook.
* Raspberry Pi and other 64-bit ARM hardware are supported from the public 1.0 release. Binions is currently in alpha, and the alpha packages are for 64-bit x86 (amd64) only.