{"id":1310,"date":"2026-11-08T08:40:00","date_gmt":"2026-11-08T08:40:00","guid":{"rendered":"https:\/\/cotocus.cn\/blog\/?p=1310"},"modified":"2026-11-08T08:40:00","modified_gmt":"2026-11-08T08:40:00","slug":"per-user-request-or-deploy","status":"publish","type":"post","link":"https:\/\/cotocus.cn\/blog\/per-user-request-or-deploy\/","title":{"rendered":"Cost Per User, Request or Deployment: Which Unit Fits Your Team?"},"content":{"rendered":"<p>Teams that run services in the cloud eventually receive the same email from finance: spending is up, please explain. A single monthly total cannot be explained, only restated. The professional response is to convert it into a unit cost, and the first real decision is which unit. This comparison sets out three common choices, cost per user, cost per request and cost per deployment, and describes what each reveals, what each hides and when to prefer it.<\/p>\n<h2>Why the choice of unit matters<\/h2>\n<p>A unit cost is only as useful as the question it answers. Divide by the wrong thing and you get a tidy ratio that points the team in the wrong direction. The three candidates below sit at different distances from the customer. Cost per user is closest to the business, cost per request is closest to the system and cost per deployment is closest to the engineering process. Mature teams usually track more than one, and the comparison explains why.<\/p>\n<h2>Option one: cost per user<\/h2>\n<p><strong>What it shows.<\/strong> The expense of serving one active person over a period, usually a month. It translates infrastructure into the language of product and pricing, so product managers and finance can use it without a technical briefing.<\/p>\n<p><strong>Strengths.<\/strong> It links directly to revenue conversations. If the cost of serving a user is rising while the plan price is flat, the margin question arrives early. It also exposes the consequences of design choices that appear free, such as storing every user&#8217;s history indefinitely.<\/p>\n<p><strong>Weaknesses.<\/strong> Users are not uniform. A light user and a heavy user are averaged together, which can hide a small group responsible for most of the expense. The definition of an active user also needs to be agreed upon, or the denominator will drift from month to month.<\/p>\n<h2>Option two: cost per request<\/h2>\n<p><strong>What it shows.<\/strong> The expense of handling one call to a service, such as a page load or an API call. It follows the system&#8217;s behaviour rather than the customer&#8217;s count.<\/p>\n<p><strong>Strengths.<\/strong> It is excellent for diagnosing design issues. A request that triggers several downstream calls costs more than its neighbours, and the unit makes the pattern visible. It also responds quickly to optimisation work, so engineers see the effect of a change within days rather than at month end. For readers designing for heavy load, the discussion of <a href=\"https:\/\/cotocus.cn\/blog\/managing-massive-web-traffic-through-modern-cloud-infrastructure\/\">keeping large volumes of web traffic manageable in the cloud<\/a> gives useful architectural context.<\/p>\n<p><strong>Weaknesses.<\/strong> Requests differ enormously in value. A health check and a checkout are both requests, but only one of them matters commercially. Averaging across them produces a figure that is difficult to act on unless requests are grouped by type.<\/p>\n<h2>Option three: cost per deployment<\/h2>\n<p><strong>What it shows.<\/strong> The expense of building, testing and releasing one change. It captures pipeline compute, test environments and the time those environments sit idle.<\/p>\n<p><strong>Strengths.<\/strong> It directs attention to the delivery process, which is often overlooked in cost conversations. Test environments left running overnight or build jobs that repeat unnecessary steps show up clearly when each release carries a price tag in the form of effort.<\/p>\n<p><strong>Weaknesses.<\/strong> A lower cost per deployment is not an unambiguous improvement. Teams can reduce it by deploying less often, which usually harms delivery speed. It is also the unit furthest from the customer, so it rarely helps with pricing.<\/p>\n<h2>Side-by-side summary<\/h2>\n<ul>\n<li><strong>Best for pricing and margin talks:<\/strong> cost per user.<\/li>\n<li><strong>Best for architecture and tuning:<\/strong> cost per request, grouped by request type.<\/li>\n<li><strong>Best for delivery pipeline hygiene:<\/strong> cost per deployment.<\/li>\n<li><strong>Most easily gamed:<\/strong> cost per deployment, by shipping less.<\/li>\n<li><strong>Most affected by definitions:<\/strong> cost per user, through the meaning of active.<\/li>\n<\/ul>\n<h2>How to combine them<\/h2>\n<p>The units are complements rather than rivals. A sensible arrangement is to report cost per user to leadership, cost per request to the teams that own services, and cost per deployment to platform and delivery owners. Each audience gets a number it can influence. The totals reconcile in the background, but nobody has to read them aloud.<\/p>\n<p>Whichever unit you adopt, document its definition, the data source and the owner. A shared definition prevents the endless debates that begin when two teams produce different figures from the same bill. A related piece on <a href=\"https:\/\/cotocus.cn\/blog\/moneyvoid-for-software-teams-and-founders-understanding-costs-cash-use-and-payment-risk\/\">how software teams and founders can read their costs and cash use<\/a> sets out the founder&#8217;s view of the same problem.<\/p>\n<h2>Building the capability<\/h2>\n<p>Introducing unit costs is as much a people exercise as a technical one. Engineers need to see billing data in terms they recognise, and finance colleagues need enough technical vocabulary to ask good questions. That shared practice is called FinOps. <a href=\"https:\/\/finopsschool.com\/\">FinOpsSchool<\/a> provides FinOps training and certification, which makes it a reasonable place for both groups to acquire a common language.<\/p>\n<h2>Implementation notes for consultants and in-house teams<\/h2>\n<p>Start with the unit your stakeholders already use informally. If product reports on monthly active users, begin there. Gather one month of data, calculate the ratio, and present it with a one-page note describing exclusions. Then add a second unit for the engineering audience. Resist the urge to build a dashboard first; a short written explanation of a single ratio changes more behaviour than a wall of charts.<\/p>\n<p>For teams earlier in their cloud journey, the <a href=\"https:\/\/cotocus.cn\/blog\/cloud-services-checklist-how-to-grow-your-digital-business-without-stress\/\">checklist for growing a digital business on cloud services<\/a> offers a practical checklist that pairs well with unit-cost reporting.<\/p>\n<h2>Conclusion<\/h2>\n<p>No single unit is correct. Cost per user serves the business, cost per request serves the system, and cost per deployment serves the delivery process. Choose according to the decision in front of you, state the definition plainly, and revisit the choice as the product matures. A team that can say what one unit costs, and why, has turned an opaque invoice into an engineering conversation.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Three common unit costs compared: what each one reveals, what it hides, and which audience should see it in a cloud engineering organisation.<\/p>\n","protected":false},"author":4,"featured_media":1311,"comment_status":"","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[330],"tags":[],"class_list":["post-1310","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-devops"],"_links":{"self":[{"href":"https:\/\/cotocus.cn\/blog\/wp-json\/wp\/v2\/posts\/1310","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/cotocus.cn\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/cotocus.cn\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/cotocus.cn\/blog\/wp-json\/wp\/v2\/users\/4"}],"replies":[{"embeddable":true,"href":"https:\/\/cotocus.cn\/blog\/wp-json\/wp\/v2\/comments?post=1310"}],"version-history":[{"count":1,"href":"https:\/\/cotocus.cn\/blog\/wp-json\/wp\/v2\/posts\/1310\/revisions"}],"predecessor-version":[{"id":1383,"href":"https:\/\/cotocus.cn\/blog\/wp-json\/wp\/v2\/posts\/1310\/revisions\/1383"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/cotocus.cn\/blog\/wp-json\/wp\/v2\/media\/1311"}],"wp:attachment":[{"href":"https:\/\/cotocus.cn\/blog\/wp-json\/wp\/v2\/media?parent=1310"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/cotocus.cn\/blog\/wp-json\/wp\/v2\/categories?post=1310"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/cotocus.cn\/blog\/wp-json\/wp\/v2\/tags?post=1310"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}