Can I Monitor Uptime and Response Time Hourly?
Key takeaways
- Hourly uptime and response-time reports come from running probes at a short interval (60 seconds or less) and grouping results into 60-minute buckets.
- A 60-second interval gives 60 samples per hour, so a 2-minute outage shows as roughly 97% hourly uptime, while a 30-minute interval can miss short outages entirely.
- Use hourly averages for trend lines and p95 for alerting and SLA reporting, since averages hide single bad minutes.
- Use 2-3 check locations with majority quorum to cut false alarms, and alert on 2-3 consecutive failures rather than a single failed check.
- Keep raw per-hour data rather than only monthly rollups so you can correlate downtime with deploys and spot response-time drift early.
Yes, you can monitor uptime and response time hourly. Any monitoring tool that lets you set a check interval of 5 minutes or less can produce hourly numbers: the probes run continuously, and a report interval groups them into 12 data points per hour. The catch is accuracy, since a 5-minute interval samples only 12 minutes of real time out of every 60 and can miss short outages entirely.
How does hourly uptime and response-time monitoring work?
Yes. Every mainstream monitor supports hourly reporting: you set a check interval (say, every 60 seconds), the tool runs probes at that frequency, and it aggregates them into hourly uptime and response-time figures. UptimeRobot's documentation covers check intervals and how results roll up into reports (UptimeRobot docs).
The real question is what interval sits behind the hourly number. One check per hour gives you a useless uptime stat; one check per minute gives you 60 data points and catches short outages. StatusPulse runs protocol-level probes on short intervals, so the hourly figure reflects real availability, and incident alerts still fire in minutes rather than waiting for the hour to close.
What does hourly uptime monitoring actually mean?
Hourly uptime monitoring means your monitor runs probes at a fixed interval, say every 60 seconds, and groups the results into 60-minute buckets. Each bucket gets its own uptime percentage and average response time, so you can see the 2 PM hour separately from the 3 PM hour instead of staring at one blended 30-day number.
Uptime percentage math for one hour
The formula is simple: successful checks divided by total checks in the hour, times 100. Run a check every minute and you get 60 probes per hour, so one failed check is 98.3% uptime for that hour. One caveat: a check that returns a 5xx counts as a failure, but a 4xx like a 404 might not, depending on what you're monitoring. That distinction matters more than most people realize when reading status codes for uptime purposes (https://blog.statuspulse.ai/post/http-status-code-monitoring-what-2xx-4xx-and-5xx-actually-mean-for-uptime).
How hourly buckets roll into SLA reporting
Daily and monthly SLA numbers are just weighted averages of the hourly buckets. If your SLA is measured monthly, 24 hourly percentages per day average out to roughly 720 data points per month, which makes it easy to spot which specific hours dragged your error budget down. Keep the raw per-hour data, not just the monthly rollup, or you lose the ability to correlate downtime with deploys.
Can I monitor response time on an hourly basis?
Yes. Most monitoring tools record every probe's response time, then roll those raw measurements into hourly aggregates: you get an average, a percentile (usually p95), or both, per hour. This is the same convention behind SLA math, where monthly uptime percentages are calculated from recorded availability windows per AWS's SLA definitions.
Average vs p95 in hourly response-time data
An hourly average divides total response time by probe count. If your API answers in 200ms for 59 minutes and 4,000ms for one minute, the average looks fine. p95 reports the value 95% of probes beat, so that one bad minute shows up as a spike instead of vanishing.
The practical rule: use hourly averages for trend lines and capacity planning, use p95 for alerting and SLA reporting. If your tool only offers averages, check whether it also records min/max per hour — a max that drifts upward while the average stays flat is your earliest degradation signal. Protocol-level probes (TCP connect time, database query round-trips) give you cleaner hourly data than URL checks, since you're measuring one hop instead of the whole stack; we cover that in database probe monitoring.
How do check intervals affect hourly uptime accuracy?
Your check interval decides how many samples an hour contains, and that number caps what an hourly uptime percentage can actually see. At a 60s interval you get 60 probes per hour, so a 2-minute outage shows up as roughly 2 failed checks and a ~97% hourly uptime. At a 30-minute interval you get 2 probes, and if the outage starts right after one check and ends before the next, the hour reports 100% while your customers saw 2 minutes of downtime.
The missed-outage problem with sparse intervals
The shortest outage an interval can detect is roughly its own length, and only if the outage happens to overlap a check. This table makes the trade-off explicit:
| Interval | Samples/hour | Shortest detectable outage |
|---|---|---|
| 30s | 120 | ~30s |
| 60s | 60 | ~60s |
| 5 min | 12 | ~5 min |
| 30 min | 2 | ~30 min |
For a paid B2B SaaS with an SLA, 60s is the practical floor. Anything sparser turns your hourly report into a guess, and protocol-level checks like the DNS probes described in 7 key DNS record types to monitor for better uptime deserve tighter intervals still.
False positives from single failed checks
The flip side: with 60 samples per hour, one failed check is 1.7% uptime loss and may be a network blip, not a real outage. Alert on 2-3 consecutive failures so a single dropped packet doesn't page you at 3 AM, while a genuine outage still trips within a minute or two.
How do check locations interact with hourly data?
Each location probes independently, so your sample count per hour is probes × checks per hour. Five locations at one-minute intervals give you 300 samples per hour; one location gives you 60. More samples means one flaky probe barely dents the hourly percentage, while a single-location setup can swing from 100% to 96% on one timeout.
Quorum checks to reduce false alarms
Quorum logic marks an outage only when a majority of locations agree. If 2 of 5 probes fail, that is likely a routing or local ISP issue, not your server, so the check reports degraded rather than down and skips the PagerDuty call. Set the quorum to a simple majority and you cut false alarms without missing real outages, since a genuine outage fails from every region at once.
The tradeoff: quorum smooths the hourly uptime number, so a location-specific failure may not move it at all. If one region matters (say, your EU customers), watch per-location response times, not just the blended hourly figure. The same logic applies to protocol-level checks, as covered in our API uptime guide.
How do I set up hourly uptime and response-time reports?
Step 1: choose the probe type for what you run
Match the probe to the service, not the other way around. HTTP probes for APIs and web apps, TCP probes for databases and queues behind private endpoints, DNS probes for anything where resolution itself is the product. A URL check on your homepage tells you almost nothing about whether your Postgres replica is reachable.
Step 2: set interval and locations
A 60-second interval gives you 60 probes per hour, so a single failed check costs you 1.7% of that hour's uptime. At a 5-minute interval, one failure is 8.3%, which is why sparse checks produce flapping hourly numbers. Use 2-3 locations and count an hour as down only when a majority of locations agree, since a single bad region otherwise generates false alarms at 3 AM. The honest trade-off: more locations at the same interval multiplies your probe count, and if you are on a free tier of 5 probes you will burn that budget on one endpoint in one region. Prioritize the region where most of your customers are, then add a second region for confirmation before you add more endpoints. Monitoring the wrong things thoroughly is worse than monitoring the right things roughly, because most outages are detectable in seconds if the critical path is what you are probing (Cron Alert on monitoring critical paths).
Step 3: configure hourly reports and alert thresholds
Set reports to roll up per hour: uptime percentage, mean and 95th percentile response time. Percentiles matter because averages hide the tail, a point the SRE literature covers well in Google's SRE book chapter on alerting. Alert on two consecutive failures to kill single-blip noise, and route to PagerDuty only for confirmed outages.
StatusPulse runs this same playbook: protocol-level HTTP, TCP, and DNS probes, hourly rollups, and alert thresholds you set per probe. Where it falls short: the free tier's 5 probes force the prioritization above rather than letting you monitor everything at once, and location coverage is thinner than Better Stack's.
What response-time thresholds should I alert on?
Start with service-type starting points, then adjust to your own baseline. A typical API endpoint tolerates 500-1000 ms before users notice. A marketing site can sit at 1000-2000 ms without complaints. A database probe should stay under 200-300 ms, because slow queries cascade into every endpoint that touches them.
Baseline before you set thresholds
Run checks for a week without alerts and read the hourly response-time numbers. Set your threshold at roughly 1.5-2x your median, not a number you copied from a forum. If your API normally answers in 180 ms, a 500 ms threshold fires on real degradation. If it normally answers in 600 ms, the same threshold fires on every deploy.
Alert on sustained breaches, not single probes. Require N consecutive failures (3-5 checks at your interval) before paging yourself. One slow probe is noise; five in a row across two locations is an outage worth waking up for.
Is hourly monitoring enough, or do I need sub-minute checks?
For most SaaS status pages, hourly reporting backed by 1-5 minute checks is enough. At a 1-minute interval you get 60 probes per hour, which is plenty to calculate a trustworthy uptime percentage and spot response-time drift.
Go sub-minute only when a check guards revenue or an SLA: your checkout path, auth endpoint, or a contract with downtime penalties. Tighter intervals also mean more probes from each location, which raises cost on most plans.
The honest tradeoff: Statuspage.io's pricing starts at $29/month, so running 30-second checks across several locations there gets expensive fast. Cheaper tools make sub-minute checks practical, but false-alarm risk rises, so keep alert thresholds loose even when checks are frequent.
How do I read hourly uptime data to spot degradation trends?
A hard outage shows up as a red hour. Degradation shows up earlier, as a slow drift in your hourly response-time series. If your p95 response time climbs from 400ms to 900ms over three days while uptime stays at 100%, that is your warning: a connection pool filling up, a disk quietly filling, a dependency getting slower.
Compare each hour against the same hour last week, not just yesterday, so daily traffic patterns don't hide the drift. Also watch the spread between p50 and p95 within an hour; a widening gap means some requests are struggling while most look fine.
StatusPulse exports hourly response-time history, so you can chart p95 per hour and alert on a threshold like "p95 doubles versus the trailing 24-hour average." That catches slow rot hours before it becomes a 3 AM page.
FAQ
How often should uptime checks run for accurate hourly reports?
A 60-second interval is the practical floor for a paid SaaS with an SLA: 60 probes per hour, so a 2-minute outage registers as roughly 97% uptime. At 5-minute intervals you get 12 samples and can miss short outages entirely. Use 2-3 locations so one flaky probe doesn't distort the hourly number.
Does hourly monitoring count as SLA-grade uptime measurement?
Yes, if the hourly buckets roll up from frequent checks and you keep the raw per-hour data. Monthly SLA figures are just weighted averages of roughly 720 hourly data points. One caveat: a monitor checking every 30 minutes can report 100% for an hour where customers saw downtime, which will not survive an SLA dispute.
Can I get hourly uptime reports emailed to me or my clients?
Most monitoring tools support scheduled email reports, though granularity varies: some send daily or weekly summaries with hourly breakdowns, others only monthly rollups. Check whether the export includes per-hour uptime and response time, not just averages. If email reports are too coarse, pull raw hourly data via API or export and build your own client-facing summary.
Why does my monitor show 100% uptime when customers saw downtime?
Sparse intervals are the usual culprit. A 30-minute check interval gives 2 probes per hour, and an outage that starts after one check and ends before the next is invisible. Single-location checks also miss regional issues, and monitors that treat 4xx responses as success will hide broken pages. Tighter intervals plus multi-location quorum checks fix this.
What is the cheapest way to get a status page with hourly monitoring?
Use a monitoring tool with a free tier and short check intervals, then host a status page yourself or on a static site fed by its API. Dedicated status-page products like Statuspage.io start at $29/month, which gets expensive if you also want sub-minute checks across multiple locations. Prioritize one region and your critical endpoints before adding more probes.