I built a developer API during baby nap times after losing 2 weeks of work to a no-code platform

Adela C — Wed, 06 May 2026 12:02:48 +0000

The backstory

A few weeks ago I was using a no-code platform to build my product. The platform restored an old checkpoint without warning and I lost 2 weeks of work overnight.

So I did what any sensible person would do: I started over, but this time building something I actually own.

What I built

Webintel is infrastructure for developers and AI agents to handle real-time price and stock change signals.

The model is simple:

Your app detects a price or stock change
You call our API with the event
We meter it, charge $0.003, and fire your webhook instantly

You focus on detection. We handle the pipeline.

The tech stack

Node.js + Express API hosted on Railway
Supabase for the database
Stripe for metered billing
npm package: npm install webintel
MCP server for AI agents: npx @adela_c/webintel-mcp
OpenAPI spec at api.webintel.io/openapi.json

The honest part

I have zero coding background. I built this entirely with Claude's help during my baby's nap times over a few sessions.

I now own everything completely. No platform can roll back my work anymore.

What makes it different

Most price monitoring tools send you an email. Webintel sends your app a webhook.

It's infrastructure, not a consumer tool. The OpenAPI spec means AI agents can use it natively without any custom integration code.

Try it

npm install webintel

Get a free API key at webintel.io — no signup required, just enter your email.

Would love feedback from developers — does pay-per-signal make sense for your use case? What's missing?

Stop scraping everything: a better way to track competitor price changes

Adela C — Fri, 17 Apr 2026 17:30:47 +0000

If you’ve ever tried to track competitor prices or product changes, you’ve probably realized something:

It’s not the idea that’s hard — it’s everything around it.

On paper, the problem sounds simple: "Know when a competitor changes price, stock, or product details."

In reality, most solutions fall into two categories, and both have trade-offs.

Scraping-based approaches

Tools like scraping platforms (e.g. Apify) are often the first place people go.

They’re powerful and flexible. You can extract almost anything from a page and build your own pipelines.

But in practice, this usually means:

running scheduled jobs
storing raw data
comparing results manually or in code
handling noise and inconsistencies

You don’t actually get "price changes" — you get snapshots of data.

Everything else is up to you.

Generic website monitoring tools

Another common approach is using page monitoring tools (e.g. Visualping).

These are much easier to set up:

paste a URL
get notified when something changes

But they tend to detect everything:

layout updates
content tweaks
minor changes that don’t matter

Which leads to a different problem:

Too many alerts, not enough signal.

And most outputs are designed for humans (screenshots, diffs), not systems.

The real problem?
Both approaches miss something important:

You don’t actually care that a page changed.

You care that something meaningful changed.

For example:

a price dropped
a product went out of stock
a new product appeared

That’s the difference between data and signal.

What actually works better?

Instead of scraping everything detecting every change, it would be more useful to focus on meaningful events only, return structured data and trigger actions automatically

In other words, going from "Something changed on the page" to "Competitor price dropped from £120 → £95"

Why does this matter?

Because once you have clean, structured change events, everything becomes easier:

you can automate pricing decisions
trigger alerts only when relevant
feed data into internal tools or AI systems

And most importantly, you remove the need to build and maintain complex scraping pipelines.

A simpler model

A more practical workflow looks like this:

Add a competitor product URL
Monitor it continuously
Receive structured events when something meaningful changes

For example:

price_drop
price_increase
stock_change

Delivered via API or webhook.

Where this is going

As more systems become automated, the need shifts from:

"collect as much data as possible" to "get the right signal at the right time"

That’s the difference between monitoring and decision-ready data

Final thought

Competitor monitoring isn’t a data problem anymore.

It’s a signal problem.

And the tools that win will be the ones that:

reduce noise
deliver structured insights
and integrate directly into workflows

If you're working on pricing, ecommerce, or automation systems, this shift is worth paying attention to.

You can see an example of this approach here:
https://webintel.io

DEV Community: Adela C