DEV Community: ZeroCost Tech

5 Problems I Hit Running a WhatsApp AI Bot 24/7 on Windows - And How I Fixed Them

ZeroCost Tech — Mon, 21 Sep 2026 19:49:51 +0000

Running a WhatsApp AI bot locally sounds simple:

WhatsApp → Node.js → Ollama → done.

In practice, keeping it running reliably 24/7 on a Windows PC taught me a few things the hard way.

Here are 5 problems I ran into — and how I fixed them.

1. The bot stopped when the terminal closed

During development, running node index.js worked perfectly.

But the moment the terminal was closed, the bot disappeared with it.

The fix

Use a process manager such as PM2:

npm install -g pm2

Then:

pm2 start index.js --name whatsapp-ai-bot

And save the process list:

pm2 save

This makes the bot much easier to manage and restart.

2. WhatsApp kept asking me to scan the QR code

Scanning a QR code every time the bot starts isn't practical for a machine that's supposed to run 24/7.

The fix

With whatsapp-web.js, use persistent local authentication:

const { Client, LocalAuth } = require('whatsapp-web.js');

const client = new Client({ authStrategy: new LocalAuth() });

The authentication session is stored locally, so normal restarts don't require pairing the account again.

3. Ollama worked — but responses were painfully slow

A local LLM means no paid AI API, but your hardware now does the inference.

Running a model that's too large can make a WhatsApp bot feel unusable.

The fix

Start with a smaller model.

For example:

ollama run llama3.2:3b

Then test response time before moving to something larger.

For a chat bot, a fast smaller model can be more useful than a smarter model that takes forever to answer.

4. One failure could crash the whole bot

Network requests fail.

Ollama may temporarily be unavailable.

Messages may contain unexpected content.

Without error handling, one bad request can take down a bot that's supposed to run unattended.

The fix

Treat every external operation as something that can fail.

For example:

try { const response = await askOllama(message.body); await message.reply(response); } catch (error) { console.error('Bot error:', error); }

Also log failures instead of silently ignoring them.

5. "$0/month" doesn't mean "zero resources"

This was an important distinction.

The setup can avoid:

VPS hosting fees
Paid AI API fees
Cloud compute bills

But the Windows machine still needs to remain powered on and connected to the internet.

For me, that's the useful part of this architecture: reuse hardware you already own instead of paying for another server every month.

The final setup

The architecture ended up being surprisingly small:

WhatsApp → whatsapp-web.js → Node.js → Ollama → Local LLM

No VPS.

No paid AI API.

No monthly hosting subscription.

If you want the complete Windows setup, source code, configuration, and step-by-step instructions, I put everything together here:

👉 Complete WhatsApp AI Bot Setup Guide + Code

https://payhip.com/b/VMK8o?utm_source=devto&utm_medium=article&utm_campaign=sale2&utm_content=5_problems

If you're building something similar, I'd also be interested to hear what problems you ran into.

How I Built a WhatsApp AI Bot That Runs for $0/Month on Windows

ZeroCost Tech — Sat, 15 Aug 2026 21:37:11 +0000

I wanted a simple WhatsApp AI bot without paying every month for cloud hosting or an AI API.

So I built one that runs on a Windows PC I already have running 24/7.

The result:

WhatsApp integration with Node.js
Optional local AI using Ollama
No VPS or cloud server required
No paid AI API required
Runs on Windows 10/11
Can restart automatically after a reboot

«The "$0/month" refers to additional software, hosting, and AI API costs. It assumes you already have the PC, internet connection, and electricity.»

The basic architecture

The setup is intentionally simple:

WhatsApp → Node.js bot → Local AI → WhatsApp reply

The Node.js application handles incoming WhatsApp messages and decides how to respond.

For AI responses, the bot can send the user's message to a locally running Ollama model and return the generated answer back to WhatsApp.

That gives us:

WhatsApp → Node.js → Ollama on localhost → Node.js → WhatsApp

No cloud AI API is required.

What you need

For the basic setup:

Windows 10 or Windows 11
Node.js LTS
A WhatsApp account
Ollama if you want local AI
A computer that can stay powered on

You don't need Kubernetes.

You don't need AWS.

You don't need Docker.

And you don't need to rent a VPS.

Connecting WhatsApp

For this project I used "whatsapp-web.js".

The first time the application starts, it displays a QR code.

You scan the QR code with WhatsApp, similar to connecting WhatsApp Web.

After authentication, the application can listen for incoming messages and send replies.

A simplified example looks like this:

const { Client, LocalAuth } = require('whatsapp-web.js');

const client = new Client({
authStrategy: new LocalAuth()
});

client.on('qr', (qr) => {
console.log('Scan the QR code to connect WhatsApp');
});

client.on('ready', () => {
console.log('WhatsApp bot is ready');
});

client.on('message', async (message) => {
if (message.body.toLowerCase() === 'hello') {
await message.reply('Hello from the bot!');
}
});

client.initialize();

"LocalAuth" stores the authenticated WhatsApp session locally.

That means you normally don't need to scan the QR code again every time the application restarts.

Protect the WhatsApp session

The authentication files should be treated like credentials.

Do not:

Upload them to GitHub
Share them with other people
Include them in downloadable source packages
Commit your ".env" file

Add sensitive files and directories to ".gitignore".

For example:

.env
.wwebjs_auth/
.wwebjs_cache/
node_modules/

Adding local AI with Ollama

The next step is connecting the bot to Ollama.

Ollama runs the language model locally on the Windows machine.

Instead of calling a paid cloud API, Node.js sends the prompt to Ollama on localhost.

A simplified request might look like this:

async function askOllama(prompt) {
const response = await fetch('http://localhost:11434/api/generate', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({
model: 'llama3.2',
prompt,
stream: false
})
});

const data = await response.json();

return data.response;
}

Then the WhatsApp handler can use it:

client.on('message', async (message) => {
try {
const answer = await askOllama(message.body);
await message.reply(answer);
} catch (error) {
console.error(error);
await message.reply('Something went wrong.');
}
});

Now the flow becomes:

A WhatsApp message arrives
Node.js receives it
Node.js sends the prompt to Ollama
Ollama generates the answer locally
Node.js sends the answer back through WhatsApp

Choosing a local model

The model you can run comfortably depends on the hardware.

Smaller models generally:

Require less RAM
Respond faster
Work better on older PCs

Larger models can provide better results for some tasks, but they require more resources.

For a small personal bot or learning project, starting with a relatively small model is usually the easiest approach.

Keeping the bot running

During development, you can simply run:

node index.js

But that isn't enough for a machine that should host the bot continuously.

You want the application to:

Start automatically
Restart if it crashes
Start again after Windows reboots

One option is using PM2:

npm install -g pm2

Then:

pm2 start index.js --name whatsapp-ai-bot

You can check its status with:

pm2 status

And view logs with:

pm2 logs whatsapp-ai-bot

For a long-running Windows setup, make sure you also configure a reliable startup mechanism so the process returns after a machine reboot.

What can you build with it?

Once the basic connection works, you can extend the bot in many directions:

AI Q&A
Group-specific commands
Personal assistants
Home automation
Local knowledge bases
API integrations
Custom system prompts
Different behavior for different groups
Message summarization
Simple internal tools

The WhatsApp connection is really just the interface.

The interesting part is what you put behind it.

A note about whatsapp-web.js

"whatsapp-web.js" is an unofficial integration that works through WhatsApp Web.

It is not the official WhatsApp Business Platform.

That makes it convenient for experiments and personal projects, but it also means you should understand the trade-offs before using it for a business-critical or production system.

For an official commercial integration, the WhatsApp Business Platform is the appropriate route to evaluate.

Why I built this

I wanted something that didn't require a cloud account, recurring hosting bill, or complicated infrastructure.

A Windows machine that was already online could do the job.

For a developer, the setup is relatively straightforward.

But there were enough small steps — Node.js setup, WhatsApp authentication, Ollama, configuration, persistent startup, and troubleshooting — that I decided to package the complete process into a beginner-friendly guide.

Complete step-by-step version

I created a downloadable guide that includes the full Windows setup and ready-to-run project files.

It covers:

Windows setup
Node.js installation
WhatsApp connection
Local authentication
Ollama setup
Local AI integration
Configuration
Running the bot continuously
Ready-to-use source files

You can find it here:

https://payhip.com/b/VMK8o?utm_source=devto&utm_medium=article&utm_campaign=sale2

If you build your own version, I'd be interested to hear what you're using your WhatsApp bot for.