DEV Community: Eva

Why Automation Creates More Work - And How to Avoid It

Eva — Sun, 06 Sep 2026 13:12:00 +0000

Automation is supposed to save time.

But sometimes it does the opposite.

You start with one simple workflow.

Then you add another trigger.

Then another action.

Then an exception.

Then an error handler.

Then a notification.

Then another tool to monitor everything.

Eventually, you realize something:

You didn't remove work.

You created a system that needs to be maintained.

I've run into this problem while building automation workflows for a digital product business.

And it changed the way I think about automation.

The automation trap

A simple workflow might look like this:

Customer buys a product
→ Product is delivered
→ Order is recorded

That's useful.

Then you think:

"Why not notify me on Telegram too?"

So you add Telegram.

Then:

"Why not track the customer in Notion?"

So you add Notion.

Then:

"Why not send a follow-up email?"

So you add an email platform.

Then:

"Why not automatically tag the customer?"

Another step.

Then:

"Why not add an AI decision?"

Another module.

None of these ideas are necessarily bad.

The problem is that every additional step creates another dependency.

More automation means more things to maintain

This is the part that's easy to overlook.

Suppose your workflow uses:

Payhip
Make
Telegram
Notion
an email platform

Now you have several systems that need to keep working together.

If one API changes, your workflow may break.

If a webhook fails, an order may not be recorded.

If a Telegram connection expires, notifications may stop.

If your Notion database changes, the automation may fail.

The automation itself becomes a small software system.

And software systems need maintenance.

The mistake I used to make

My instinct was to automate anything that looked repetitive.

That sounds reasonable.

But repetitive doesn't automatically mean worth automating.

For example, imagine a task takes 30 seconds and happens twice a month.

Automating it might take two hours.

That's not really automation.

That's just moving the work somewhere else.

A better question is:

How often does this happen, and how expensive is it when I do it manually?

That changes the decision.

What I automate now

I try to prioritize three types of tasks.

1. Repetitive tasks

If I perform the same action over and over again, automation makes sense.

For example:

Customer buys a product
→ Record the order
→ Send a notification

That's a predictable workflow.

2. Event-driven tasks

I also prefer workflows that start because something actually happened.

For example:

Payment received
→ Start workflow

This is better than constantly checking whether something happened.

3. Tasks where mistakes are expensive

Some manual tasks are simple but easy to forget.

For example:

recording an order
sending a notification
updating customer status
delivering a digital product

If missing one of these creates a real problem, automation can be valuable.

What I don't automate

I try not to automate things just because they are possible.

For example:

complex workflows used only occasionally
processes that require frequent human judgment
tasks that are faster to do manually
workflows with too many dependencies
systems that I don't fully understand

This last one is particularly important.

If I can't explain what a workflow does in a few sentences, it's probably too complicated.

Start with one workflow

One of the best changes I made was simply starting smaller.

Instead of trying to build an entire automated business at once, I started with one workflow:

Payhip
↓
Make
↓
Telegram
↓
Notion

A purchase happens.

The automation processes it.

The order gets recorded.

I receive a notification.

That's enough.

Once that workflow is reliable, I can decide whether another automation is actually necessary.

Think in systems, not individual automations

There's another lesson here.

A business doesn't need dozens of disconnected automations.

It needs a small number of reliable systems.

For example:

Delivery system

Payment
→ Digital product delivery

Order system

Payment
→ Order record
→ Customer record

Notification system

Important event
→ Telegram notification

Follow-up system

Customer event
→ Email sequence

Each system should have a clear responsibility.

That makes troubleshooting much easier.

A simple rule

The rule I'm using now is:

Automate repetitive work, not complexity.

If automation removes a task I don't want to do repeatedly, it's probably useful.

If automation creates five new things I need to monitor, I probably made the workflow too complicated.

The goal isn't maximum automation

This is probably the biggest lesson I've learned.

I used to think the goal was:

"Automate as much as possible."

Now I think the goal is:

"Remove as much unnecessary work as possible."

Those sound similar.

They're not.

A business with 20 complicated automations isn't necessarily more efficient than one with 5 simple ones.

Reliability matters more than the number of automations.

What I'm building

This is also the reason I'm building NomadOS.

The goal isn't to create another giant automation platform.

Tools like Make already give you enormous flexibility.

The harder problem is deciding how those tools should actually be used in a digital product business.

I'm interested in building practical workflows around real business processes:

digital product delivery
order tracking
customer management
notifications
lead capture
follow-up

The idea is to start with simple workflows and gradually connect them into a system.

Without creating another system that needs constant babysitting.

Final thought

Automation should make your business quieter.

Not louder.

If you're spending more time checking whether your automations are working than you spent doing the original task manually, that's probably a sign to simplify.

Start with one repetitive problem.

Automate it.

Make it reliable.

Then decide whether you actually need the next automation.

That's the approach I'm taking now.

How to Automate Digital Product Delivery with Payhip, Make, and Telegram

Eva — Wed, 02 Sep 2026 14:08:30 +0000

If you sell digital products, one of the first things you'll probably want to automate is delivery.

A typical manual workflow looks like this:

Customer buys a product
→ You receive the order
→ You check the payment
→ You send the download
→ You record the customer
→ You send a confirmation

It works.

But once you start getting more orders, doing the same steps manually becomes unnecessary work.

I wanted a simple way to connect the tools I was already using.

The workflow I ended up with looks like this:

Payhip
↓
Make
↓
Telegram
↓
Notion

Here's how it works.

1. Payhip handles the purchase

The customer purchases a digital product through Payhip.

Payhip becomes the starting point of the workflow.

Instead of manually checking every order, the purchase event can trigger the next step.

The important part here is that the automation starts with an event.

You don't want to constantly check whether something happened.

You want the system to tell you when it happened.

2. Make handles the automation

Make sits between the different services.

The basic idea is:

Payhip event
→ Make receives the data
→ Make processes the order
→ Make sends the information to the next service

This's where you can decide what should happen after a purchase.

For example:

record the order
notify yourself
send customer information to another system
trigger another workflow

The nice thing about this approach is that you don't need to build a custom backend just to connect a few services.

3. Telegram handles notifications

I use Telegram for notifications because I don't want to constantly check dashboards.

For example, when a new order arrives, Make can send notification like:

New order received

Product: NomadOS Lite
Customer: customer@example.com

This turns the workflow into something I can monitor without opening Payhip every few minutes.

4. Notion stores the data

The final step is recording the order in Notion.

For example, my database can contain:

Customer	Product	Status	Date
customer@example.com	NomadOS Lite	Paid	2026-09-02

Now the order doesn't just trigger a notification.

It becomes part of a simple customer/order database.

This becomes much more useful when you have multiple products.

The complete workflow

The basic architecture looks like this:

Payhip
↓
Purchase event
↓
Make
↓
┌───────────────┐
│ Process order │
└───────┬───────┘
↓
┌────┴────┐
↓ ↓
Telegram Notion
↓ ↓
Notify Record

The important thing is that each tool has a relatively simple responsibility.

Payhip handles the transaction.

Make handles the automation logic.

Telegram handles notifications.

Notion stores the information.

What I learned

The interesting part wasn't actually connecting the tools.

The difficult part was deciding what not to automate.

It's easy to keep adding another step:

"Maybe I should automate this too."

Then another one.

And another one.

Eventually, the automation itself becomes something you have to maintain.

So I've started following a simple rule:

Automate repetitive work.

Don't automate complexity just because you can.

Start with one reliable workflow.

Then add another only when the manual work actually becomes a problem.

That's the approach I'm using while building my own digital product automation system.

#How I built an automated digital product workflow with Payhip,Make,Telegram and Notion

Eva — Fri, 31 Jul 2026 14:00:23 +0000

How I built an automated digital product workflow with Payhip,Make,Telegram and Notion

Selling digital products sounds simple:

Create a product → receive payment → deliver the product.

But the operational workflow quickly becomes messy.

You need:

Payment handling
Customer notifications
Delivery automation
Order tracking

So I built a lightweight automation stack using:

Payhip
+
Make
+
Telegram Bot
+
Notion

The architecture

Customer Payment
↓
Payhip
↓
Make Automation
↓
Telegram Notification
↓
Notion Database

Example workflows

1. Telegram Order Notification

When a customer purchases a product:

Payment event triggers automation
Telegram receives notification
Order information is recorded

2. Digital Product Delivery

After payment confirmation:

Delivery workflow starts
Customer receives instructions
Order status is tracked

Why I open sourced this

Many creators don't need a complex backend.

They need simple, reliable automation that connects existing tools.

You can find the complete workflow examples here:

👉 GitHub Repository:
https://github.com/Eva-311/hermes-automation-examples

Questions for other builders:

What tools are you currently connecting manually in your workflow?

How I automated digital product delivery using Payhip,Make,Telegram and Notion

Eva — Mon, 20 Jul 2026 12:39:45 +0000

Selling a digital product usually starts with s simple flow:

Create product → Add payment → Deliver files

But after running the workflow.I found there're many steps behind the scenes.

Examples:

checking payments
sending delivery messages
updating customer records
tracking orders

So I started building an automated workflow using:

Payhip
Make
Telegram
Notion

System Architecture

The workflow:

Customer Purchase
↓
Payhip
(Payment Receive)
↓
Webhook Trigger
↓
Telegram Bot
(Customer Notification)
↓
Notion Database
(Order Records)

Payment layer

Payhip handle the transaction.

After a successful purchase,the payment event triggers the automation workflow.

Automation Layer

Make works as the connection layer.

It receives webhook data and handles:

data processing
workflow routing
sending notifications
updating databases

Communication Layer

Telegram Bot provides instant notifications.

This allows customers to receive updates without manual messages.

Data Layer

Notion becomes the operational dashboard.

It stores:

customer information
order records
product data
business tracking information

What I learned

Building automation isn't only about connecting tools.

The difficult part is designing a reliable workflow where each component works together.

This system eventually became part of NomadOS,A Digital Product OS for creators who want to automate repetitive operation.

I'm continuing to improve the workflow and test new automation ideas.

What automation workflows are you currently building?

How I Built a No-Code Digital Product Automation System with Telegram,Notion and Make

Eva — Tue, 14 Jul 2026 12:18:02 +0000

</> Markdown

How I Built a No-Code Digital Product Automation System with Telegram,Notion and Make

Running a digital product business sounds simple.

Someone buys your product,receives access,and you move on.

But when you mange everything alone,many small tasks start adding up:

Checking new orders
Sending delivery messages
Updating customer records
Tracking product performance
Following up with users

Eventually,you spend more time managing system than creating products.

So I built a simple automation workflow using:

Payhip
Make
Telegram Bot
Notion

The Architecture

The workflow looks like this:

The idea is simple:

Every important event should automatically create the next action.

Step 1:Payment Trigger

When a customer purchases a digital product,Payhip sends the purchase information through a webhook.

The webhook contains:

-Customer information
-Product information
-Order details

Instead of manually checking sales,the automation handles it.

Step 2:Process Data with Make

Make receives the webhook and processes the information.

The automation can:

-Format customer data
-Create database records
-Trigger notifications

This becomes the connection layer between different tools.

Step 3:Store Everything in Notion

Notion becomes the operating dashboard.

Example database:

Products Database

Track:

-Product name
-Price
-Status
-Updates

Customers Database

Track:

-Customer name
-Purchase history
-Communication status

Orders Database

Track:

-Order ID
-Product
-Date
-Revenue

Now the business data is automatically organized

Step 4:Telegram Automation

Telegram is useful because many creators already have communities there.

The automation can send:

-Welcome messages
-Product delivery information
-Updates
-Notifications

Lessons Learned

The biggest lesson from building this system:

Automation isn't about connecting more tools.

It's about reducing the number of things you need to manually check.

A good automation system should give creators more time to focus on:

-Creating products
-Growing communities
-Improving their business

Question

What's the most annoying manual task in your current workflow?

I would love to hear how other creators are solving automation problem.

Building a Digital Product Automation System with Telegram,Make,and Notion

Eva — Tue, 07 Jul 2026 12:02:14 +0000

Running a digital product business usually starts simple.

Create a product.
Receive an order.
Send the files.
Track customers.

But as the number of customers grows,manual operations become a problem.

In this article,I will show how I built a simple automation architecture using Telegram,Make,and N otion.

The problem

A typical digital product workflow requires several manual steps:

1.Customer purchases a product
2.Order information is recorded
3.Customer receives delivery instructions
4.Creator updates customer records
5.Follow-up message are sent

Doing this manually works at the beginning,but it becomes difficult to maintain.

The architecture

The system is built around three components:

Customer Action
↓
Telegram Bot
↓
Webhook
↓
Make Automation
↓
Notion Database

Each component has a specific role.

Used as the communication layer.

It can handle:

. welcome messages
. delivery notifications
. user interactions

Make

Used as the automation engine.

It handles:

. receiving webhook data
. processing information
. triggering actions

Notion

Used as the database layer.

It stores:

. customers
. products
. orders
. leads

Building the workflow

Step 1:Create your database structure

A simple structure:

Products Database

Customers Database

Orders Database

Leads Database

Keeping data separated makes future automation easier.

Step 2:Connect Telegram with Make

The workflow:

Telegram message
↓
Webhook trigger
↓
Process data
↓
Send response

This creates a simple communication pipeline.

Step 3:Save information into Notion

When a new event happens:

. create a new customer record
. update order information
. trigger follow-up actions

Now the system can automatically maintain your database.

Lessons learned

While building this system,I found that the hardest part was not connecting APIs.

The hardest part was designing a reliable data structure.

A good automation system starts with:

. clear data models
. predictable workflows
. error handing

Without these,adding more automation only creates more complexity.

Final thoughts

Tools like Telegram,Make,and Notion are powerful individually.

But when combined properly,they can become a lightweight operating system for solo creators.

I'm continuing to improve this approach and explore how automation can help more independent builders reduce repetitive work.

🧩How we built a Telegram automation system using Make,Nation,Webhooks,and Payhip

Eva — Thu, 02 Jul 2026 08:38:07 +0000

✍️In this post,I want to break down a simple automation system we built for handling digital product sales automatically.

The goal was to remove manual work from:

.lead handling
.order processing
.product delivery
.CRM logging

We used a combination of:

.Telegram Bot(user interface)
.Make(automation engine)
.Webhooks(trigger layer)
.Notion(CRM database)
.Payhip(payment+delivery)

🧠System overview

The flow looks like this:

User → Telegram Bot → Webhook → Make Scenario → Notion + Payhip

1.Telegram Bot as the entry point

We used Telegram as the main interface because:
.easy user interaction
.supports real-time messaging
.no frontend needed

Users can:
.send messages
.trigger commands
.start interactions

2.Webhook trigger layer

Every incoming Telegram event is sent to a webhook.

This allows us to:

.capture user actions
.pass structured data to automation system
.decouple UI from backend logic

3.Make as the automation engine

Make handles the main logic flow:
.parsing incoming data
.routing conditions
.calling APIs
.transforming payloads

Example scenarios:

.new lead→create Notion record
.purchase→trigger delivery flow
.message→AI response(optional)

4.Notion as CRM system

We use Notion to store:
.users
.leads
.orders
.status tracking

Each event updates the database automatically.

This gives a simple CRM layer without building a backend.

5.Payhip for payment+delivery

Payhip handles:
.checkout flow
.payment processing
.product delivery

Once payment is confirmed:

→Make receives webhook
→system updates Notion
→user gets delivery message via Telegram

⚙️Why we built it this way

We didn't want to built a traditional SaaS backend.

Instead,we focused on:

.no server infrastructure
.no frontend development
.minimal maintenance
.fast iteration

This stack allows a solo builder to run a fully automated digital product business.

🧩What the system actually solves

This setup removes manual work in:

.responding to leads
.tracking customers
.delivering products
.updating CRM

It replaces all of that with automation.

⚠️What we learned

Even though the system works technically,we realized something important:

Automation alone is not the value.

What matters more is:

.clarity of outcome
.simplicity of flow
.how users perceive the system

🚀Next step

We are now refining this system into a more focused use case:

A sales automation system for solo creators selling digital products

Instead of a "tool stack",we are shaping it into a clear productized system.

💬Question

If you were building a solo business today,would you prefer:
.simple automation systems like this
.or fully custom-built backend solutions?

We built an automation system...but nobady cared

Eva — Mon, 29 Jun 2026 07:18:45 +0000

We spent weeks building a Telegram automation system.No one cared.

A week ago,we thought we had something valuable.

We built a system called Hermes---a Telegram-based automation stack using Make,Notion,and Payhip.

The idea was simple:
automate digital product sales end-to-end.

Webhook→Telegram→AI processing→Notion CRM→Payhip delivery.

Technically,it worked perfectly.

Everything ran 24/7.

No manual work needed.

But there was a problem.

Nobody cared.

Not because it didn't work-
but because nobody understood why they should use it.

We realized something painful:

👉We built a tool.
👉But people don't buy tools.
👉They buy outcomes.

So we started asking a different question:

Instead of:

"What can this system do?"

We asked:

"What problem does this actually solve?"

And the answer changed everything.

We are no longer building:

.a Telegream bot
.an automation tool
.or a Make workflow system

We are now thinking in a different direction:

→ A system that helps creators sell digital products automatically

Not automation for the sake of automation.

But:

.automatic lead capture
.automatic sales handling
.automatic delivery
.automatic CRM logging

Same stack:
.Telegram(interface)
.Make(logic engine)
.Notion(CRM)
.Payhip(payments)

Different framing.

Different product.

Different story.

What we learned:

Building infrastructure is easy.

But without a clear user-facing outcome,it's invisible.

Now we are rebuilding Hermes as:

-A sales automation system for solo creators selling digital products.

Not a tool.

A system that runs your business in the background.

If you are building solo tools or automation systems:

What's your biggest struggle right now?

Would love to hear how other are thinking about this.

Eva
on June 29, 2026

How I Connected Telegram,Notion and Make to Automate Digital Product Delivery

Eva — Sat, 20 Jun 2026 09:48:44 +0000

How I Connected Telegram,Notion and Make to Automate Digital Product Delivery

As a solo founder,I quickly realized that selling a digital product isn't the hard part.

Managing everything after the sale is.

Every order created a series of manual tasks:

.Sending access information
.Updating customer records
.Tracking purchases
.Organizing customer data

None of these tasks were difficult,but they became repetitive very quickly.

So I decided to automate the process.

The Goal

I wanted a workflow that could:

1.Receive customer information automatically
2.Store records in central database
3.Trigger follow-up actions without manual intervention
4.Reduce operational workload

The Stack

I chose the following tools:

.Telegram
.Make
.Notion

Each tool had a specific role.

Telegram acts as the communication layer.

It allows users to receive information quickly and provides a simple way to interact with the workflow.

Make

Make is the automation engine.

It connects different services together and handles the logic behind the workflow.

Notion

Notion serves as the operational database.

Customer records,order information,and workflow status are stored in one place.

The Workflow

The basic process looks like this:

Telegram→Make→Notion

When an event is triggered:

1.Make receives the data
2.The data is processed
3.A new record is created inside Notion
4.Follow-up actions can be triggered automatically

The entire process happens without manual data entry.

What Went Wrong

The first version wasn't perfect.

At one point,customer records were being created with incomplete information.

The automation appeared to be working correctly.

No error messages appeared.

After several hours of debugging,I discovered that one field inside a Make module was mapped incorrectly.

It was a small mistake,but it affected the entire workflow.

This taught me an important lesson:

Automation systems don't fail in dramatic ways.

They often fail quietly.

That's why monitoring and testing are just as important as building.

Lessons Learned

After building this workflow,three lessons stood out:

1.Start Simple

It's tempting to automate everything.

Don't.

Building the smallest workflow that solves a real problem.

2.Test Every Connection

Most issues don't come from tools.

They come from assumptions.

Always verify that data is moving correctly between systems.

3.Automation Is About Operations

The technical setup is usually straightforward.

The difficult part is designing a process that makes sense long term.

Final Thoughts

I'm still improving this workflow and experimenting with new approaches.

For now,the biggest benefit isn't saving time.

It's reducing the number of repetitive decisions I need to make everyday.

As a solo founder,that's often more valuable than the automation itself.

Have you built any automation workflows using Telegram,Make,Notion,or similar tools?

I'd love to hear how you're approaching it.