Datadog is overkill for your side project

Datadog is a genuinely excellent product. At scale — with dozens of microservices, hundreds of engineers, SLO dashboards wired to on-call rotations — it earns every dollar. This post isn't an attack on Datadog.

It's a question for the developer running a side project, a small SaaS, or an internal tool: are you actually getting value from a full observability platform, or are you paying for infrastructure you don't use?

What full observability platforms are good at

• Long-term retention — Search logs from 30, 90, or 365 days ago.
• Cross-service correlation — Trace a request across ten microservices with a single query.
• Dashboards and SLOs — Visualise p99 latency over time; alert when error rate breaches a threshold.
• Team-scale access control — Different teams see different services; audit logs of who searched what.

If you need those things, use Datadog (or Grafana, or Honeycomb, or whatever fits your stack).

What side projects actually need

Most side projects have a much simpler observability need: I want to know what my code is doing right now, and I want to know when something breaks.

That breaks down into three concrete things:

1. Real-time visibility — Watch the app run live when you're testing or debugging.
2. Error alerts — Get notified when an exception happens, with enough context to reproduce it.
3. Basic audit trail — Know that a job ran, finished, and didn't error.

A full observability platform handles all three, but so does a much lighter setup.

The cost of complexity

Setting up Datadog on a new project means: installing an agent, configuring log collection, deciding on tags and indexes, creating a retention filter, and — if you're on the free tier — discovering that the features you need require a paid plan. That's an afternoon of work before you've logged a single meaningful event.

For a side project that gets an hour of attention per week, that setup cost never pays for itself.

The simpler alternative

For real-time visibility, BunnyLogs takes about two minutes to set up:

pip install bunnylogs

import logging
from bunnylogs import BunnyLogsHandler

logging.getLogger().addHandler(BunnyLogsHandler("your-uuid"))

You get a URL. Open it in a tab. Your logs appear. That's it.

For a Django app, add it to settings.py:

LOGGING = {
    "version": 1,
    "disable_existing_loggers": False,
    "handlers": {
        "bunnylogs": {
            "class": "bunnylogs.BunnyLogsHandler",
            "uuid": "your-uuid",
            "level": "WARNING",
        },
    },
    "root": {
        "handlers": ["bunnylogs"],
        "level": "WARNING",
    },
}

Now every WARNING and above from anywhere in your Django app — including Django's own request errors and ORM exceptions — streams to a URL you can watch live or share with a collaborator.

Where BunnyLogs doesn't replace Datadog

To be direct: BunnyLogs streams logs in real time and retains recent history. It doesn't do long-term retention at scale, cross-service tracing, or complex log analytics. If you need those, use the right tool.

But if you're a solo developer or a small team and you've been putting off setting up observability because the options felt like too much — start simple. You can always migrate to a more powerful stack when you've outgrown it.

Try BunnyLogs free →