DEV Community

Oleksandr
Oleksandr

Posted on

Your App Is Online. So Why Can't Anyone Use It?

Imagine checking your production dashboard on a Monday morning.

Server uptime: 100%.

API health checks: passing.

Database: connected.

Error rate: within normal limits.

Response times: looking good.

Everything is green.

Then a customer reports that they cannot complete a purchase.

You investigate. The homepage loads. Product pages open. The API responds. Authentication works.

But the checkout process gets stuck after the customer confirms their address.

Your monitoring says the application is healthy.

Your customer says it is broken.

And both observations can be technically correct.

The problem with measuring whether software is alive

Most monitoring systems are designed to answer specific questions:

Is the server responding?

Is the database reachable?

Is the API returning successful responses?

Are response times within acceptable limits?

Are errors increasing?

These are important questions. Nobody should stop monitoring infrastructure health.

But they don't necessarily answer the question that matters most:

Can someone actually use the product to accomplish what they came here to do?

An application isn't a collection of independent endpoints from the user's perspective.

It's a sequence of connected actions.

A customer doesn't care that five API calls succeeded if the sixth one prevents them from completing an order.

A student doesn't care that the learning platform is online if their submitted assignment never gets saved.

A developer doesn't care that the deployment dashboard is healthy if the application silently serves outdated data.

The system can remain technically available while its most important functionality is broken.

How a healthy system can produce a broken experience

Consider a few hypothetical scenarios.

  1. Every component works, but the workflow doesn't

Imagine an online store.

The following operations all work:

Product search.

Product details.

Customer authentication.

Shopping cart retrieval.

Address validation.

Payment provider connection.

Individual health checks pass.

However, the checkout process fails because the frontend sends an address identifier that the order service no longer recognizes.

Neither service is necessarily unhealthy.

The integration between them is broken.

This is one reason why monitoring individual components cannot replace monitoring complete user journeys.

  1. The application returns successful responses containing bad information

An API can return HTTP 200 while delivering information that is technically valid but functionally incorrect.

For example:

A dashboard displays yesterday's figures instead of today's.

An inventory service returns an old stock count.

A search endpoint returns results but excludes recently added records.

A notification service reports successful delivery before the message actually reaches its destination.

From an infrastructure perspective, these operations may look successful.

From a product perspective, they can be failures.

A successful response is not necessarily a successful outcome.

  1. Partial failures are difficult to notice

Modern applications depend on multiple services.

A single user action might involve a frontend, authentication provider, database, background worker, external API, and notification system.

If one dependency becomes slow or unreliable, the entire experience can deteriorate without the application going completely offline.

For example, a background worker might stop processing jobs.

The main application continues responding normally.

Users can submit requests, but the results never arrive.

The problem may remain invisible until someone notices that their task has been waiting for an unusually long time.

This is particularly dangerous when the system acknowledges an action before its final result is available.

Monitor outcomes, not just components

I don't think the solution is to replace infrastructure monitoring.

It's to add another layer.

Instead of checking only whether individual components are functioning, monitor whether important user journeys are completing successfully.

For an online store, that might mean checking:

User journey

What to verify

Registration

A new account can actually be created

Login

The user can authenticate and access their account

Search

Relevant results are returned

Checkout

An order reaches the expected final state

Payment

The transaction has a confirmed outcome

Order history

The completed order appears correctly

Notice the difference.

A basic health check might confirm that the payment endpoint responds.

A workflow check should verify that a test transaction reaches the expected state without creating unintended charges.

These are different levels of confidence.

Five things worth monitoring beyond uptime

If I were reviewing the monitoring strategy of an existing application, I'd start with these areas.

  1. Completion rate

How many users who start an important workflow actually finish it?

A sudden drop can reveal problems that ordinary availability metrics miss.

However, completion rates need context. A change in user behavior, traffic composition, or product design can also affect them.

  1. Time to successful completion

It's not enough for an operation to eventually succeed.

If a task normally takes a few seconds but now takes several minutes, the application may be technically available while becoming practically unusable.

  1. Data freshness

When was the information last updated?

This matters especially for dashboards, inventory, financial systems, search indexes, and applications that depend on background processing.

A response containing stale information can be more dangerous than an explicit error because users may not realize anything is wrong.

  1. Background job completion

Track more than whether workers are running.

Monitor:

Jobs waiting in queues.

Age of the oldest pending job.

Failed and repeatedly retried jobs.

Jobs that were accepted but never completed.

A running worker doesn't guarantee that work is being processed correctly.

  1. Critical integration health

An external dependency can be reachable while a particular operation fails.

Monitor the actual interactions your product relies on, not simply whether a third-party domain responds.

A practical approach: test the user's journey

You don't necessarily need a complicated monitoring platform to begin.

Start with one critical workflow.

For example, if your product depends on users creating and retrieving records:

Create a dedicated test account.

Submit a uniquely identifiable test record.

Verify that the system accepts it.

Retrieve the record through the normal user-facing interface.

Confirm that the expected data is present.

Clean up the test data if appropriate.

Alert someone if the workflow fails.

There are important precautions.

Synthetic tests should use isolated test accounts and controlled data. They should not accidentally send real notifications, charge real payment methods, or trigger irreversible business operations.

They should also be designed so that repeated execution doesn't create an ever-growing collection of test records.

Most importantly, a synthetic test should verify the same meaningful behavior that a real user depends on.

A test that simply calls an endpoint and checks for HTTP 200 doesn't prove that the workflow works.

Don't turn monitoring into another source of noise

There is one more problem worth considering.

If every small deviation creates an alert, the monitoring system becomes difficult to trust.

Teams eventually learn to ignore notifications, including the important ones.

Not every metric needs an alert.

I'd distinguish between:

Informational signals: something changed, but no immediate action is required.

Warnings: a workflow is degrading and deserves investigation.

Critical incidents: an important user action is failing or data integrity may be at risk.

The thresholds should reflect the actual impact of the failure.

For example, one failed synthetic test might justify a warning or a second verification attempt. Repeated failures across multiple checks might justify escalating the issue.

The goal isn't to generate more alerts.

It's to make important failures harder to miss.

The question I'd ask before calling a system healthy

Instead of asking only:

"Is everything running?"

I'd ask:

"Can a real user complete the most important task this product promises to perform?"

That question changes how we think about reliability.

Infrastructure health is necessary.

Successful requests are necessary.

But neither automatically proves that the product is delivering its intended value.

A system should be measured not only by whether its components are alive, but also by whether the outcomes users depend on are actually happening.

Let's discuss

I'm interested in how other developers approach this.

  1. Have you ever had a production system where every dashboard was green, but users were still experiencing serious problems?

  2. Do you actively monitor complete user journeys, or do you mostly rely on infrastructure and endpoint health checks?

  3. What's one important failure mode you've seen that ordinary uptime monitoring completely missed?

I'm especially interested in practical examples.

Because sometimes the most misleading production status isn't a red dashboard.

It's a perfectly green one.

Top comments (0)