{"id":1294,"date":"2026-11-07T08:40:00","date_gmt":"2026-11-07T08:40:00","guid":{"rendered":"https:\/\/cotocus.cn\/blog\/?p=1294"},"modified":"2026-11-07T08:40:00","modified_gmt":"2026-11-07T08:40:00","slug":"devops-shared-vocabulary-faq","status":"publish","type":"post","link":"https:\/\/cotocus.cn\/blog\/devops-shared-vocabulary-faq\/","title":{"rendered":"Shared DevOps Vocabulary: Questions Teams Ask Before Starting"},"content":{"rendered":"<p>DevOps programmes stall for many reasons, but one of the least discussed is vocabulary. Development, operations, security and business stakeholders each bring their own meanings for words like &#8220;deployed,&#8221; &#8220;incident&#8221; and &#8220;environment.&#8221; When those meanings are never reconciled, teams argue about performance that nobody measured the same way. A shared DevOps vocabulary, written down and owned, removes that friction at the source. What follows answers the points clients raise most frequently whenever we propose opening an engagement with this exercise.<\/p>\n<h2>What exactly is a shared DevOps vocabulary?<\/h2>\n<p>It is a short document, usually a page or two, that lists the handful of terms your delivery and operations decisions depend on. For each term it gives one definition in plain language, a concrete test that tells you whether the definition is met, and the name of the role responsible for keeping the entry current. It is not a textbook glossary of every DevOps concept. It covers only words that, if misunderstood, would cause a wrong decision, a missed commitment or a pointless dispute.<\/p>\n<h2>Why do experienced teams still disagree on basic terms?<\/h2>\n<p>Because experience is local. An engineer who spent five years at a company where &#8220;release&#8221; meant a tagged build will carry that meaning into the next job. A product manager from a different background may use &#8220;release&#8221; to mean the moment customers see a feature, which might be weeks after the code shipped behind a flag. Both are competent; their histories differ. Mergers, outsourcing and multi-vendor projects multiply the effect, because each organisation imports its own dialect.<\/p>\n<p>A related problem is that tools encode definitions silently. A CI server, a ticketing system and a monitoring platform may each have a field called &#8220;status,&#8221; and the values mean subtly different things in each. People then repeat the tool&#8217;s word without noticing that it does not match the word in the contract.<\/p>\n<h2>Which terms should we define first?<\/h2>\n<p>Start with the words that appear in commitments: contracts, service levels, sprint goals and status reports. In most engagements that shortlist includes:<\/p>\n<ul>\n<li><strong>Deployed.<\/strong> Code running in production, or code running in any environment? Behind a feature flag or visible to users?<\/li>\n<li><strong>Released.<\/strong> Often worth separating from deployed, so that technical and customer-facing milestones are tracked independently.<\/li>\n<li><strong>Incident.<\/strong> Any alert, any user-visible degradation, or only events that breach a service level? Without agreement, incident counts are meaningless.<\/li>\n<li><strong>Severity levels.<\/strong> What distinguishes a severity-one event from a severity-two? Define by customer impact, not by how stressed the on-call engineer felt.<\/li>\n<li><strong>Environment names.<\/strong> &#8220;Staging,&#8221; &#8220;UAT&#8221; and &#8220;pre-prod&#8221; are used interchangeably in some organisations and as three distinct stages in others.<\/li>\n<li><strong>Uptime or availability.<\/strong> Measured from where, over what window, and does planned maintenance count?<\/li>\n<li><strong>Done.<\/strong> The team&#8217;s definition of done for a work item, including whether documentation and automated tests are required.<\/li>\n<\/ul>\n<p>For guidance on capturing these alongside functional needs, our engineering blueprint on <a href=\"https:\/\/cotocus.cn\/blog\/deep-dive-the-complete-engineering-blueprint-for-web-project-requirements\/\">structuring requirements for a web project<\/a> shows where a terminology section fits naturally.<\/p>\n<h2>How detailed should each definition be?<\/h2>\n<p>Detailed enough that two people applying it independently would reach the same answer. A practical pattern is three parts:<\/p>\n<ol>\n<li>A one-sentence meaning in everyday words.<\/li>\n<li>A test or source of truth, such as &#8220;the deployment record in the pipeline shows a successful production stage.&#8221;<\/li>\n<li>Explicit exclusions, for example &#8220;rollbacks within ten minutes are not counted as separate deployments.&#8221;<\/li>\n<\/ol>\n<p>Anything longer tends not to be read. If an entry needs a paragraph of caveats, the term is probably covering two ideas and should be split.<\/p>\n<h2>Who should own each definition?<\/h2>\n<p>Assign ownership by expertise and accountability. Engineering leads typically own technical states such as deployed and environment names. Service owners or SRE leads own incident and severity definitions. Product owners own released and the customer-facing meaning of done. The owner does not have to write every word, but they approve changes, record the date and announce them. One owner per term avoids the situation where three people each believe someone else will update the page.<\/p>\n<h2>What happens when definitions need to change?<\/h2>\n<p>They will, and that is healthy. Introducing feature flags may change what released means; adopting a new monitoring platform may alter how availability is calculated. The rule is simple: the owner edits the entry, notes the effective date and the reason, and informs everyone who reports on that term. Reports that compare periods across the change should carry a short note so readers know the definition shifted. Silent changes are what erode trust in figures, not changes themselves.<\/p>\n<h2>Does this conflict with industry frameworks?<\/h2>\n<p>No. Frameworks such as ITIL or published SRE practices offer excellent reference definitions, and many teams adopt them directly. The vocabulary document simply records which reference you follow and any local adjustments. Writing &#8220;incident: as defined in our ITIL-based process, plus any customer-reported outage&#8221; is perfectly valid. The essential thing is that your chosen reference is stated openly and easy for anyone to find.<\/p>\n<h2>How do we handle terms that differ between vendors?<\/h2>\n<p>Multi-vendor programmes are where vocabulary drift is most expensive. A cloud provider, a managed security partner and an application team may each report &#8220;availability&#8221; using their own calculation, and the numbers will never line up. Rather than forcing every vendor to change its internal language, record a mapping: our term, the vendor&#8217;s equivalent, and any difference in calculation. Contractual reporting should then use your definition, with the vendor translating. This keeps escalation calls focused on the service rather than on whose arithmetic is correct, and it gives procurement a clear basis for future agreements. Review the mapping whenever a vendor changes its reporting format.<\/p>\n<h2>Where should the vocabulary live?<\/h2>\n<p>Close to the work. Good locations include the repository README for engineering terms, the top of the incident process page for operational terms, and the project charter for commercial terms. Link them together rather than duplicating text. Some teams also add short tooltips in their dashboards or ticket templates so the meaning appears exactly where the word is used.<\/p>\n<h2>How does this help a consulting engagement specifically?<\/h2>\n<p>External consultants arrive with their own dialect. Agreeing on vocabulary during the first week aligns expectations for deliverables, prevents disputes over whether a milestone was met, and makes handover far smoother because the client&#8217;s team inherits a written reference instead of relying on memory. It also surfaces scope differences early. If you are scoping new work, our list of <a href=\"https:\/\/cotocus.cn\/blog\/questions-to-ask-before-building-a-custom-web-application-the-complete-guide\/\">questions worth raising before a custom application build begins<\/a> pairs well with a vocabulary session.<\/p>\n<h2>Is this only relevant to large enterprises?<\/h2>\n<p>Smaller teams benefit just as much, sometimes more, because they often lack a formal process that would otherwise force terms into the open. A five-person startup arguing about whether a feature is &#8220;live&#8221; loses proportionally more time than a large organisation with a release calendar. The document can be correspondingly small: five or six entries may be enough. Teams building resilience practices in demanding markets have found the same; our case discussion of <a href=\"https:\/\/cotocus.cn\/blog\/engineering-resilience-how-practical-devops-cloud-automation-and-sre-shape-modern-it-teams-in-japan\/\">how SRE and cloud automation shaped IT teams in Japan<\/a> illustrates how clear language supports reliable operations.<\/p>\n<h2>How do data teams approach the same problem?<\/h2>\n<p>Data teams face it in a particularly acute form, since one ambiguous metric can propagate through every report built on top of it. The discipline of agreeing definitions and assigning owners is central to data quality and governance work. Professionals who want structured preparation in those practices may explore <a href=\"https:\/\/dataopsschool.com\/\">DataOpsSchool, which offers DataOps training, certification and consulting<\/a> covering governance and quality within a broader operating model.<\/p>\n<h2>What is a sensible first step this week?<\/h2>\n<p>Book a single forty-five-minute session with representatives from development, operations and the business side. Ask each person to write their definition of deployed, incident and done on a card before discussing them. Compare the cards. The differences that appear are your starting list. Agree on wording for those three, assign owners, publish the page where everyone works, and add further terms only as they prove necessary. Precision in language is one of the cheapest reliability improvements available to any DevOps team.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Deployed, released, incident, done: answers to common questions about building a shared DevOps vocabulary with clear definitions and a named owner for each term.<\/p>\n","protected":false},"author":4,"featured_media":1295,"comment_status":"","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[330],"tags":[],"class_list":["post-1294","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\/1294","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=1294"}],"version-history":[{"count":1,"href":"https:\/\/cotocus.cn\/blog\/wp-json\/wp\/v2\/posts\/1294\/revisions"}],"predecessor-version":[{"id":1324,"href":"https:\/\/cotocus.cn\/blog\/wp-json\/wp\/v2\/posts\/1294\/revisions\/1324"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/cotocus.cn\/blog\/wp-json\/wp\/v2\/media\/1295"}],"wp:attachment":[{"href":"https:\/\/cotocus.cn\/blog\/wp-json\/wp\/v2\/media?parent=1294"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/cotocus.cn\/blog\/wp-json\/wp\/v2\/categories?post=1294"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/cotocus.cn\/blog\/wp-json\/wp\/v2\/tags?post=1294"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}