How I built an API monitoring tool with FastAPI, SQLite, and a Telegram Bot

Dario Leone — Tue, 09 Jun 2026 19:15:26 +0000

I come from a mechanical engineering background and started building with Python to solve real problems. Last month I launched PingMon — an API monitoring SaaS (pingmon.ai). Here's what I learned about choosing the right stack for a solo project.

Why FastAPI over Django or Flask

I needed async from day one. The core job of a monitoring tool is making HTTP requests to check if endpoints are up — hundreds or thousands of them. Blocking I/O would kill performance.

FastAPI gives me async natively, without the complexity of Django's ASGI setup or the boilerplate of Flask + gevent.

Here's what the main check loop looks like (simplified for readability):

async def check_endpoint(url): try: async with aiohttp.ClientSession() as session: start = time.monotonic() async with session.get(url, timeout=aiohttp.ClientTimeout(10)) as r: elapsed = int((time.monotonic() - start) * 1000) return {"is_up": True, "response_time": elapsed, "status": r.status} except (asyncio.TimeoutError, aiohttp.ClientError): return {"is_up": False, "response_time": None, "status": None}

The async loop runs every minute for Pro users, every 5 minutes for free users. That's about 10,000 checks per day on a single $6 Hetzner VPS without breaking a sweat.

Why SQLite is enough for a SaaS product

Everyone told me I needed PostgreSQL. I ignored them and used SQLite. Here's why it works:

No separate database server to manage. No connection pooling config. No backup scripts. SQLite lives in a single file that I can back up with a simple cron job.

SQLite handles about 50 concurrent writes per second. For a monitoring tool where each check is a single INSERT and the dashboard does a handful of SELECTs, that's more than enough. The bottleneck is always the HTTP checks, not the database.

One thing to watch out for: by default, SQLite uses a rollback journal where reads block writes and vice versa. Enable WAL mode to fix this. I set it on startup:

PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;

That's it. I've been running this in production for weeks. No locks, no corruption, no issues. I'll switch to Postgres when I have 100+ concurrent users — not before.

Telegram bot for alerts in 15 lines

Instead of building an email notification system that would end up in spam folders, I used a Telegram bot. It's absurdly simple:

Your bot: send a POST request to api.telegram.org/bot{token}/sendMessage with chat_id and text. That's it.

The alert function in my code (simplified):

async def send_alert(chat_id, endpoint_name, error): message = f"🔴 {endpoint_name} is DOWN\nError: {error}" url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage" payload = {"chat_id": chat_id, "text": message} async with aiohttp.ClientSession() as session: async with session.post(url, json=payload) as resp: return resp.status == 200

Users connect their Telegram within 30 seconds. No SMTP config, no deliverability issues, no spam filters.

What I wish I knew before starting

FastAPI + SQLite + Telegram Bot is a powerful combo for solo developers. Three things I'd tell my past self:

Keep the schema simple. I started with three tables and expanded when needed. Premature optimization is dangerous when you're still figuring out what your product actually needs.

Don't fight async. Everything from the HTTP checks to the database calls should be async from the start. Converting sync to async later is painful.

Ship the simple version first. My V1 was a single Python file with 200 lines. It worked. The current version has proper structure and error handling, but the core logic hasn't changed.

The whole thing runs on a $6 Netcup VPS behind a Caddy reverse proxy with automatic SSL.

If you're building something similar or have questions about the stack, I'm happy to help.

PingMon is live at pingmon.ai if you want to see it in action — free tier available.

Thanks for reading.

Dario

I built a SaaS without being a developer. Here's how it actually works.

Dario Leone — Mon, 08 Jun 2026 11:50:41 +0000

I'm a 25 year old machine technician from Germany. Nine years of metal processing. No CS degree. No bootcamp.

I tried learning to code for years. Did every tutorial. Started courses. Never finished a single one. Every time I hit a wall, I stopped.

Then something clicked a few weeks ago.

I stopped trying to become a developer. I started trying to build a product.

What I did instead:

I set up an AI agent (Hermes) for architecture, research and planning — and paired it with Claude Code for implementation. My role became: product decisions, testing, deploying. Not typing.

The result after 4 weeks: PingMon (pingmon.ai) — an API monitoring tool that's live, working, and slowly getting traffic.

Tech stack (all chosen by AI, reviewed by me):
Python 3.11 / FastAPI
SQLite
Vanilla HTML + CSS + JS (no framework)
Stripe for payments
Docker / docker-compose
Caddy for reverse proxy + SSL
Netcup VPS
Umami Analytics

What it does: Pings APIs and websites every minute. Alerts via Telegram, Slack or Email when something breaks. Includes SSL monitoring, domain expiry tracking, and a public status page. Free tier available. Paid from 12€/month.

What I actually did:

Designed the architecture (what goes where, which tech fits)
Wrote the prompts that generated the code
Set up the server, DNS, domain, SSL — myself
Tested every feature before launch
Handled the bugs, the crashes, the "why won't this deploy" moments
Made all product decisions — pricing, features, UX
Deployed at 3am after a family wedding. While everyone was dancing. Also yes.

What I didn't do:

Write most of the code
Know the frameworks beforehand
Have an exit plan
What I learned:

Having an idea. Planning it out. Building it. Making it real.

But the most important thing I learned: I actually love building this. The process. The decisions. Solving problems.

That feeling alone makes it worth it. I started this as an experiment. I'm continuing because it's the first thing in years that truly fulfills me.

Why I'm posting this:

I see questions every week: "Can I build something if I can't code?" or "Is AI-assisted development real or a scam?"

This is my honest answer: yes, you can ship a working product. But you need to understand the system, not just copy-paste prompts. You need to know what you want, test it, and fix it when it breaks.

I'm not here to sell you PingMon. I want honest feedback from experienced devs: does this setup count as building a product? What am I missing?

I know this is a controversial topic. Some will say it doesn't count. Others will say this is exactly how building works now. I want to hear both sides.

I'll answer everything. Including the hard questions.

pingmon.ai

DEV Community: Dario Leone

How I built an API monitoring tool with FastAPI, SQLite, and a Telegram Bot

I built a SaaS without being a developer. Here's how it actually works.