DEV Community: Eva

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.