
Heroku remains a popular platform for deploying web applications, APIs, and services — especially for startups and smaller teams who value simplicity over infrastructure complexity. But Heroku's architecture introduces specific monitoring considerations that don't apply to traditional servers.
Free and Eco tier dynos "sleep" after 30 minutes of inactivity. When a request arrives to wake a sleeping dyno, it takes 20-30 seconds to respond — which looks like a timeout to most monitoring tools and to users.
If you're on a sleeping dyno plan, either:
Standard dyno plans and above don't sleep and behave more like traditional servers.
Heroku restarts all dynos approximately once every 24 hours. These restarts are intentional but cause brief downtime — typically 1-3 seconds. Your uptime monitor will likely catch at least one of these per day.
Configure your monitor to require 2-3 consecutive failures before alerting to avoid false alarms from daily restart events.
By default, deploying a new version to Heroku causes a brief period where the old dynos are stopped and new ones are starting. Using Heroku's preboot feature (available on paid plans) eliminates most deploy downtime by starting new dynos before stopping old ones.
Every Heroku application should expose a health endpoint. This endpoint should:
# Django example (also see how-to-monitor-django-applications)
def health(request):
try:
from django.db import connections
connections['default'].cursor()
return JsonResponse({"status": "ok"})
except Exception:
return JsonResponse({"status": "error"}, status=503)
// Node.js/Express example
app.get('/health', async (req, res) => {
try {
await db.query('SELECT 1');
res.json({ status: 'ok' });
} catch (err) {
res.status(503).json({ status: 'error' });
}
});
Point an external uptime monitor at your health endpoint:
https://yourapp.herokuapp.com/health or your custom domainThis provides continuous external verification that your Heroku app is accessible and its dependencies are working.
Heroku Scheduler is a free add-on for running periodic tasks. Like any cron system, scheduler jobs can fail silently. Use heartbeat monitoring to confirm your scheduled jobs run successfully:
# At the end of your scheduled job
import requests
requests.get(os.environ.get('HEARTBEAT_URL'))
Add the heartbeat URL as a Heroku config var (heroku config:set HEARTBEAT_URL=...).
If you have worker dynos running background jobs (Celery, Sidekiq, custom workers), these need separate monitoring from your web dynos. Workers don't expose HTTP endpoints, so use heartbeat monitoring:
If your Heroku app uses a custom domain, Heroku provisions an SSL certificate automatically via ACM (Automated Certificate Management). However, certificate renewal can fail if:
SSL certificate monitoring catches these failures before they affect users.
Heroku applications often depend on add-ons — Heroku Postgres, Heroku Redis, SendGrid, Cloudinary. These add-ons can have their own outages. While you can't directly monitor third-party add-ons, your health endpoint should check that connections to critical add-ons (especially the database) are functioning.
Heroku add metrics to their dashboards for response time and throughput, but external response time monitoring gives you the user's perspective — including DNS resolution time and network latency that Heroku's internal metrics don't capture.
Configure response time thresholds in your uptime monitor — for Heroku applications, be aware that:
| Monitor | Check | Interval | Notes |
|---|---|---|---|
| Web health endpoint | HTTP uptime | 1 min | 3-failure confirmation |
| Worker heartbeat | Heartbeat | 5 min | Set in Heroku Scheduler |
| SSL certificate | SSL monitoring | Daily | For custom domains |
| Domain expiry | Domain monitoring | Weekly | Via registrar WHOIS |
Domain Monitor provides all of these monitoring types in a single dashboard, making it straightforward to set up comprehensive Heroku application monitoring.
Monitor your Heroku application at Domain Monitor.
A subdomain takeover lets an attacker claim your subdomain by exploiting dangling DNS records. Learn how it happens, real-world examples, and how DNS monitoring detects it.
Read moreMean time to detect (MTTD) measures how long it takes to discover an incident after it starts. Reducing MTTD is one of the highest-leverage improvements in reliability engineering.
Read moreBlack box monitoring tests your systems from the outside, the way users experience them — without access to internal code or infrastructure. Learn how it works and when to use it.
Read moreLooking to monitor your website and domains? Join our platform and start today.