esc
  • WorkflowsPages
  • Case studiesPages
  • Machine Learning FoundationsLearn
  • AI EngineeringLearn
  • AI Guardrails & Red TeamingLearn
  • UI/UXLearn
  • Design SystemsLearn
  • Production System DesignLearn
  • Book a callContact
  • Download ResumeContact
Let’s talk

I’ll build the agent for it.

Usage Monitoring: Learning What Users Really Do With Your System

How to count which features, endpoints, and clients use a system, how to collect that data safely, and how to use it for capacity, billing, and product choices.

In short

Usage monitoring counts which features, endpoints, and clients use a system, to check whether it is used the way the team expected.

14 min readFree

What You Will Learn

Every system has users, and those users do things. Some open one page every day. Some never touch a feature you spent months building. Usage monitoring is the habit of tracking what people and client programs actually do with a system, how often they do it, and who they are in business terms. You will learn what to measure, how to collect the data without wasting resources or exposing people's personal details, and how teams use the results to make decisions about capacity, cost, and what to build or remove.

Key words

Usage monitoring
Tracking how people and clients use a system: which features, endpoints, and resources they touch, how often, and by whom.
Telemetry
Data that a running system sends out about itself. It can include logs, numbers, traces, and events.
Metric
A number measured again and again over time, such as the count of calls in an hour.
Event
One thing that happened, such as one file upload or one API call. Many events are later added up into metrics.
Endpoint
One web address in an API that does a job, such as /forecast/hourly for a weather service.
API
Application Programming Interface. A set of rules that lets one program ask another program for data or work.
API key
A secret code a client sends with each call so the system knows which client is calling.
Tenant
One customer or organization that shares a system with others but has its own data and limits.
Rate limit
A cap on how many calls a client can make in a short window, such as one minute.
Quota
A cap on total use over a longer period, such as a month. Quotas often match what a customer paid for.
Adoption
The share of users who have tried a feature, and how many keep using it.
Capacity planning
Estimating how much computing power, storage, and network a system will need in the future.

What Does Usage Monitoring Mean?

Many teams first watch whether their system is running. That is health and availability work. Usage monitoring asks a different question: is the system being used in the way we expected? A system can be fully up and still be used for the wrong things, or be used so heavily by one client that everyone else slows down.

Azure's architecture guidance lists monitoring the day-to-day use of a system among the common goals, and it says the aim is to spot trends that could lead to problems later. In other words, usage data is an early warning tool as well as a report card. It also helps with a quieter problem. If nobody checks usage, features that people have stopped using stay in the product for years, and the code still has to be run, tested, and paid for.

What Should You Measure?

Usage monitoring is only useful if you measure the right things. Most usage work starts with four kinds of numbers. Each one answers a different question about the system.

  • Request counts per endpoint

    How many calls each web address receives in a time window. This shows which parts of the API do the real work and which are rarely touched.

  • Active users

    How many different people or accounts used the system in a day, week, or month. Counting unique users is more useful than counting page loads, because one person can load many pages.

  • Feature adoption

    How many users have tried a feature and how many keep returning to it. A button that is clicked once by everyone may matter less than a menu used daily by a few people.

  • Per-tenant or per-client consumption

    How much each customer or API key uses of calls, stored data, and bandwidth. This is the number that links usage to cost and to fair sharing.

Business events matter as much as raw counts. Microsoft's guidance on usage analysis says that page views can be a weak signal, because a user may open a product page and leave. Tracking specific actions, such as completing a purchase or submitting a form, tells you more about what people want.

Usage is only one of several signals. Keep the difference clear, because the same data source can feed several kinds of monitoring. The sub-topic below shows how usage differs from the others.

Usage Compared With Other Signals

  • Health

    Asks whether the parts of the system are running right now. Health work is about the present state, not about who is using what.

  • Performance

    Asks how fast requests are handled and how much work the system completes. It cares about response times and queues, which other lessons cover in detail.

  • Security

    Asks whether someone is attacking the system or using it in a harmful way. A sudden spike in calls can be either a success or an attack, so usage and security data often need to be read together.

  • Usage

    Asks what people actually do, how often, and how much it costs. It is the signal that guides product and money decisions.

A quick test helps. If the question is about the future shape of demand, cost, or product choices, you are doing usage work. If the question is about whether something is broken or slow right now, you are doing a different kind of monitoring.

How Do You Collect Usage Data?

Usage data does not appear by itself. The application must be instrumented, which means code is added so that it sends out a record each time something useful happens. Microsoft's monitoring guidance describes two common ways to move this data. In a pull model, an agent next to each app instance collects data at intervals. In a push model, each instance sends its events to a queue or stream as they occur. Push suits application telemetry, because events are sent as they occur.

  1. 1

    Decide the business questions first

    Write down what you need to know, such as which endpoints each key calls, or which features new customers try in their first week. Then you know which events to record.

  2. 2

    Add event points where users act

    Put a small piece of code at each point that matters, such as when a call finishes or a button is pressed. Each event should carry a name, such as the endpoint or feature name.

  3. 3

    Attach the grouping labels

    Add labels like the feature name, the client's API key ID, or the tenant ID. These labels let you split the totals later into groups.

  4. 4

    Add up the events into metrics

    Counting raw events for every question gets slow and costly. Summing them by hour or day into a few numbers keeps the data small.

  5. 5

    Store the summaries and review them

    Keep the totals for trends and reports. Look at them on a regular schedule, because usage questions are usually about patterns over weeks, not seconds.

Standard tools can help. OneUptime's guide covers feature usage analytics with OpenTelemetry custom metrics.

The next sub-topic covers the two rules that matter most when you collect usage: keep the data private and keep the cost of collecting it low.

Keep Data Aggregated and Private

Usage data can reveal a lot about people. The safest default is to count behavior, not to record who did what. A team that builds a usage system should ask whether it needs a name, an email address, or a precise location for each event. In most cases a random anonymous ID or the client's account code is enough to split the counts.

Azure's guidance on usage analysis also shows a limit of anonymous IDs. A person who uses two browsers, or clears cookies, can be counted twice. That means the same person can be counted more than once.

Tip

Keep only what you will use. If a field does not answer one of your business questions, leave it out. Less personal data is easier to protect, cheaper to store, and easier to explain to customers.

Keep the Overhead Low

Usage monitoring must not slow down the thing it measures. Azure's guidance says that performance monitoring should not overload the system, and it recommends adjusting how much detail is gathered. The same care applies to usage work. Every extra event costs a little time to create, a little network space to send, and money to store.

  • Count in memory first

    Keep a running total in the app and send it every minute, instead of sending one message per call.

  • Send events in batches

    Group many events into one message. This cuts the number of network trips.

  • Keep the detail you need

    Store daily totals for old data and fine-grained events only for the last few days.

How Do You Act on Usage Data?

Numbers are only useful if they change a decision. Usage data supports four common kinds of choices. Each one needs a clear question before you open the charts.

  • Capacity planning

    If calls grow by a steady amount each month, you can estimate when current servers will be full and buy or add capacity before users feel slow responses.

  • Billing and quotas

    Per-client counts show what each customer used, so you can bill for it or cap it. The same counts let you check whether a customer is near a limit.

  • Finding unused and busy features

    Features with almost no users are candidates to simplify or retire. Features with heavy use are candidates to improve or protect.

  • Deciding where to optimize

    A single endpoint that takes most of the calls is the best place to spend effort on speed, caching, or cost, because a small gain there affects many users.

The next sub-topic explains how usage data turns into limits that protect a shared system.

Rate Limits and Quotas From Usage Data

Usage data tells you what a normal client looks like. From that, you can set a rate limit, which controls speed, and a quota, which controls the total. DZone's guide explains that short-term rate limits smooth out bursts of traffic and protect the back end, while quotas enforce business terms such as paid plans.

Zuplo gives an example of tiers. A free key may get a small number of calls per hour, while an enterprise key gets far more. The exact numbers are a business choice. Usage data is what lets you pick them with confidence, because you can see what each tier really consumes today.

Tip

Watch the limits as well as the usage. DZone recommends alerts for customers who are close to a limit or over it, so you can contact them before they are blocked.

Worked Example: A Weather API

Imagine a team that runs a public REST API for a weather product. Clients send HTTP requests to endpoints such as /forecast/hourly and /forecast/daily, and each client identifies itself with an API key. The team wants to know where the load comes from, so it follows the steps below.

  1. 1

    Chart daily calls per endpoint

    The team counts calls to each endpoint every day. One line rises much faster than the others. That line is /forecast/hourly.

  2. 2

    Chart daily calls per API key

    Next, the team groups the same calls by key. It finds that three customers' keys make up most of the traffic on that endpoint.

  3. 3

    Measure the share

    The data shows that /forecast/hourly drives most of the traffic, and that three customers account for that load. The team now knows the single most important endpoint and the few clients who depend on it.

  4. 4

    Set rate limits

    The team sets a per-key rate limit on the hourly endpoint. The limit sits above what normal customers use, so the three large clients keep working, but a single runaway script cannot take down the service.

  5. 5

    Plan capacity

    The team projects the growth of hourly calls and adds servers and cache space for that endpoint, instead of scaling the whole API by the same amount.

  6. 6

    Design a paid tier

    Because the hourly data is valuable and costly to serve, the team creates a paid tier that includes a higher quota on that endpoint. Usage data shows what the tier must cover, and billing data shows what to charge.

The key lesson is that the team did not guess. It used counts per endpoint and per key to find one hot spot, then used that same data for three different jobs: protecting the system, planning hardware, and shaping the product.

Quick check

A new travel-booking API has one endpoint, /prices/live, that gets 85% of calls from a single key. Other clients barely use it. Which action does the usage data support best?

Try It: Count Calls Per Endpoint

The code below does the core of the weather example in miniature, using sample data in which the hourly endpoint takes 60% of calls. Each event is one call, made with an API key to an endpoint. The program counts the calls per endpoint and shows each endpoint's share of the total. It uses only the standard library, and it has fixed data, so the output is always the same.

Python
from collections import Counter

# Each event is one call: (API key, endpoint)
events = [
    ('key-a', '/forecast/hourly'),
    ('key-a', '/forecast/hourly'),
    ('key-b', '/forecast/hourly'),
    ('key-c', '/forecast/daily'),
    ('key-a', '/forecast/hourly'),
    ('key-b', '/history'),
    ('key-c', '/forecast/hourly'),
    ('key-a', '/forecast/daily'),
    ('key-b', '/forecast/hourly'),
    ('key-c', '/history'),
]

total = len(events)
per_endpoint = Counter(endpoint for _, endpoint in events)

print(f'Total calls: {total}')
for endpoint, count in sorted(per_endpoint.items()):
    share = 100 * count / total
    print(f'{endpoint:<16} {count:>3} calls  {share:5.1f}%')

Output

Total calls: 10
/forecast/daily    2 calls   20.0%
/forecast/hourly   6 calls   60.0%
/history           2 calls   20.0%

Read the result the way the team did. The hourly endpoint is the hot spot. In a real system the events would come from logs or a metrics pipeline, and you would add the key and the time window as extra labels. The same counting idea scales up, but the questions stay the same.

Common Mistakes to Avoid

  • Counting page loads as users

    A page load is not a person, and a person can load many pages. Count unique users and key actions instead.

  • Chasing vanity numbers

    Pick numbers that lead to a choice.

  • Reading one day as a trend

    A single spike can come from a one-time event. Look at weeks of data before you change limits or retire a feature.

  • Collecting personal data by default

    Extra fields create privacy risk and cost. Collect only what answers a question you have.

Check Your Understanding

Read the short scenario below. The answer needs the idea of usage monitoring, not just a memory of the definition.

Quick check

Your photo-sharing app's storage costs doubled this month, but the number of active users stayed flat. Which usage data would you look at first to find the cause?

If the data shows that a few large accounts upload very large video files, the next step is a choice, not a single fix. You could set a per-account storage quota, compress uploads, or offer a paid plan with more space. Each choice uses the usage numbers to decide, and you can check the next month's totals to see whether it worked.

Key Takeaways

  • Usage monitoring answers 'who uses what'

    It tracks endpoints, users, features, and per-client resource use, and it is separate from checks on health, speed, and security.

  • Collect events, then add them up

    Instrument the app at the points where people act, label the events, and store summaries to keep cost and overhead low.

  • Protect privacy by design

    Count behavior with anonymous or account-level labels, and collect only the fields you need.

  • Use the numbers to decide

    Capacity, quotas, paid tiers, and the choice to optimize or retire a feature should all rest on usage data.

Sources

How is this lesson?

Last updated on 18 November 2026

Learn with me

Every lesson is free. I add new ones as I learn. Have a question, or want help with your own work? Book a short call.