We've been building automations with n8n for a while now, and one of the things we like about it is how APIs start to feel like building blocks.
Need data from a CRM? Add a node.
Need to update a spreadsheet? Add a node.
Need an AI model somewhere in the workflow? Add a node.
You connect a trigger, add a few steps, move some data around, and suddenly a process that used to require someone clicking through three different systems just happens on its own.
Then we needed to send an SMS.
And for some reason, that one step made the workflow feel more complicated than it should have been.
The Workflow Wasn't Complicated
Imagine a simple appointment workflow.
New Appointment
↓
Check Customer Details
↓
Prepare Confirmation
↓
Send SMS
Nothing particularly exciting.
The business already has an Android phone.
The phone already has a SIM card.
They already use that number to text customers.
But the automation couldn't use it.
The workflow could talk to cloud applications on the other side of the world, but it couldn't tell the Android phone sitting on the desk:
Send this message.
That bothered us more than it probably should have.
Not Every SMS Use Case Needs to Start With a Telecom Platform
There are good SMS providers out there, and they solve a much larger problem.
If you're sending at serious volume, operating across multiple countries, or building something where telecom infrastructure is a core part of the product, using a proper SMS provider makes complete sense.
But that wasn't the problem we kept thinking about.
We were thinking about smaller, more local workflows.
A clinic sending appointment reminders.
A school sending notifications.
A small CRM following up with a customer.
An internal operations tool alerting a staff member.
An n8n workflow that reaches a step where it simply needs to send a text message.
In many of these cases, the business already has a phone.
It already has a SIM.
It may even already have a mobile plan they use for exactly this kind of communication.
The missing piece isn't the ability to send an SMS.
The missing piece is giving the workflow access to that ability.
So We Started Thinking About the Phone Differently
What if the Android phone wasn't something outside the automation?
What if it was just another resource the workflow could use?
Something like this:
CRM
↓
n8n
↓
Send SMS
↓
Android Phone
From the workflow's point of view, we wanted the experience to be boring.
Give it a destination.
Give it a message.
Choose a device or SIM if necessary.
Send.
The messy part of talking to the Android device shouldn't have to live inside every CRM, ERP, or automation we build.
We wanted an API between the workflow and the phone.
That idea eventually became Relayion.
Who We Actually Built Relayion For
Relayion isn't meant to replace every SMS provider.
That's not the goal.
We're building it for developers and automation builders working on the smaller, awkward use cases that don't always fit neatly into a large communications platform.
The person building an internal tool.
The developer automating a local business.
The team connecting an existing CRM to n8n.
The indie developer building a small SaaS.
The self-hoster who already has the hardware and wants to make it useful.
Sometimes the requirement really is this simple:
When my workflow reaches this step, send an SMS using this Android device.
We think that should be easier.
The n8n Node Was an Obvious Next Step
Once we looked at Relayion from that perspective, building an n8n community node started to feel obvious.
We don't want someone building a workflow to think about Relayion's API every time they need to send a message.
Ideally, they add a node.
[ New Appointment ]
↓
[ Prepare Message ]
↓
[ Relayion: Send SMS ]
Configure the device.
Choose the SIM.
Map the phone number and message from previous nodes.
Run the workflow.
That's the developer experience we're working toward.
The API still matters, of course. Developers should be able to integrate Relayion directly into their own applications.
But n8n is where the idea really clicked for us.
Because Relayion itself is basically a bridge.
On one side, you have APIs and automated workflows.
On the other, you have an Android phone with a physical SIM card.
Relayion just lets the two talk.
Sometimes the Capability Already Exists
We think we have a habit in software development of looking for another cloud service whenever we need a new capability.
And often, that's exactly the right answer.
But sometimes the thing you need is already sitting on a desk.
It just doesn't have an API.
That's the problem we're trying to solve with Relayion.
We're still early, and we're currently working on making the n8n integration easier for automation builders.
If you use n8n and have ever needed to send SMS from a local Android device, we'd genuinely be interested in hearing about your workflow.
What were you trying to automate?
We're curious how many other people have reached the same annoying step in an otherwise perfectly good workflow.
Top comments (0)