{"id":87228,"date":"2026-07-09T14:28:16","date_gmt":"2026-07-09T21:28:16","guid":{"rendered":"https:\/\/www.jamasoftware.com\/?p=87228"},"modified":"2026-07-09T14:28:31","modified_gmt":"2026-07-09T21:28:31","slug":"blog-developer-velocity","status":"publish","type":"post","link":"https:\/\/www.jamasoftware.com\/legacy\/blog\/developer-velocity\/","title":{"rendered":"How to Improve Developer Velocity Without Sacrificing Quality"},"content":{"rendered":"<p><img decoding=\"async\" class=\"aligncenter size-full wp-image-87230\" src=\"https:\/\/www.jamasoftware.com\/media\/2026\/07\/How-to-Improve-Developer-Velocity-Without-Sacrificing-Quality.png\" alt=\"Developers in discussion at monitors.\" width=\"1024\" height=\"576\" srcset=\"https:\/\/www.jamasoftware.com\/legacy\/media\/2026\/07\/How-to-Improve-Developer-Velocity-Without-Sacrificing-Quality.png 1024w, https:\/\/www.jamasoftware.com\/legacy\/media\/2026\/07\/How-to-Improve-Developer-Velocity-Without-Sacrificing-Quality-300x169.png 300w, https:\/\/www.jamasoftware.com\/legacy\/media\/2026\/07\/How-to-Improve-Developer-Velocity-Without-Sacrificing-Quality-800x450.png 800w\" sizes=\"(max-width: 1024px) 100vw, 1024px\" \/><\/p>\n<p><span style=\"font-weight: 400;\">Artificial intelligence (AI) coding assistants can make individual coding tasks appear faster, while organizational delivery metrics lag. The speed may show up in commits and pull requests (PRs), while customer-visible delivery stays flat. Those gains get absorbed somewhere between the individual keyboard and the production release, lost to downstream bottlenecks.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Vice Presidents (VPs) and Directors of Engineering often see individual activity rise while release performance stays flat. We can make individuals faster, but making the whole system faster without compromising quality is harder, especially as teams scale across software, systems, hardware, quality, and verification.\u00a0<\/span><\/p>\n<p><span style=\"font-weight: 400;\">This blog covers the metrics, requirement practices, and traceability habits that help teams improve developer velocity without trading away quality.<\/span><\/p>\n<h2><b>What Is Developer Velocity?<\/b><\/h2>\n<p><span style=\"font-weight: 400;\">Engineering teams improve developer velocity by delivering valuable software to customers faster and more efficiently. The emphasis sits on outcomes, which means shipping features that solve real problems and create measurable business impact.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">We need to separate three terms that get used interchangeably. Velocity describes how much work a team can reliably complete in a sprint, which makes it a planning and predictability signal. Productivity looks at how efficiently value is created per unit of effort. Throughput captures the total productive capacity moving through the system over a period. Developer experience covers the conditions that produce output more than output itself, and sustainable velocity depends on those conditions holding over time.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Enterprise velocity benchmarks are most useful when they combine technology, working practices, and organizational support with team-level output. The clearest signal comes from treating velocity as a property of the delivery system.<\/span><\/p>\n<h2><b>Why Developer Velocity Stalls as Engineering Teams Scale<\/b><\/h2>\n<p><span style=\"font-weight: 400;\">Scaling slowdowns usually emerge from the system around the team. Each contributing factor is reasonable on its own, and together they compound into delivery drag:<\/span><\/p>\n<ul>\n<li style=\"font-weight: 400;\" aria-level=\"1\"><b>Coordination overhead grows quickly:<\/b><span style=\"font-weight: 400;\"> As teams grow, dependencies, handoffs, review queues, and release coordination consume capacity before added headcount improves delivery.<\/span><\/li>\n<li style=\"font-weight: 400;\" aria-level=\"1\"><b>Unclear or shifting requirements force rework:<\/b><span style=\"font-weight: 400;\"> Late changes ripple through design and verification plans and are far harder to absorb once development is already underway.<\/span><\/li>\n<li style=\"font-weight: 400;\" aria-level=\"1\"><b>Late-stage defects multiply the cost of every miss:<\/b><span style=\"font-weight: 400;\"> A missed requirement is easy to clarify while the system is still being defined, but expensive to fix once teams are integrating, testing, or certifying the finished product.<\/span><\/li>\n<li style=\"font-weight: 400;\" aria-level=\"1\"><b>Context-switching and fragmented tooling drain capacity invisibly:<\/b><span style=\"font-weight: 400;\"> When a developer waits too long for tests to run, the problem goes cold, they move to another task, and they later pay to rebuild the context they&#8217;d already paid for once.<\/span><\/li>\n<\/ul>\n<p><span style=\"font-weight: 400;\">Frequent interruptions, parallel project assignments, and fragmented tools force developers to spend mental energy rebuilding context that could otherwise be devoted to solving the problem at hand. These constraints are easier to reduce when leaders measure flow instead of individual activity.<\/span><\/p>\n<h2><b>How to Measure Developer Velocity the Right Way<\/b><\/h2>\n<p><span style=\"font-weight: 400;\">Measurement can turn good intentions into bad incentives when we choose the wrong signals. Wrong metrics can steer us toward worse outcomes.<\/span><\/p>\n<h3><b>Story Points and Lines of Code Mislead in Predictable Ways<\/b><\/h3>\n<p><span style=\"font-weight: 400;\">Story points support team planning better than individual measurement, and using them for performance evaluation destroys their value as planning tools. Story points completed are often less useful productivity signals than cycle time and lead time. Lines of code miss a different problem. Different languages and styles can express similar functionality in very different line counts, and the metric may reward verbose code and gaming behavior. Activity-based metrics like these provide a weak view of software quality or team effectiveness.<\/span><\/p>\n<h3><b>Delivery Flow Metrics Tell a Truer Story<\/b><\/h3>\n<p><span style=\"font-weight: 400;\">Change lead time and deployment frequency help describe throughput, while failed deployment recovery time and change failure rate help describe stability across<\/span><a href=\"https:\/\/dora.dev\/guides\/dora-metrics\"> <span style=\"font-weight: 400;\">delivery and stability metrics<\/span><\/a><span style=\"font-weight: 400;\">. Flow-oriented metrics add flow efficiency, the percentage of time spent on active work versus waiting, which exposes the queues and handoffs that pure speed metrics miss. Cycle time carries one caveat worth respecting. When leaders fixate on delivery speed alone, teams can cut quality and accumulate technical debt.<\/span><\/p>\n<h3><b>Outcome-Based Signals Beat Output Vanity Metrics<\/b><\/h3>\n<p><span style=\"font-weight: 400;\">A useful measurement program uses several dimensions. Trying to<\/span><a href=\"https:\/\/queue.acm.org\/detail.cfm?id=3454124\"> <span style=\"font-weight: 400;\">use a single metric<\/span><\/a><span style=\"font-weight: 400;\"> to define productivity creates blind spots. We need to look at multiple dimensions together, so leaders can see tension between speed, collaboration, satisfaction, quality, and flow. Balanced measurement frameworks do this by weighing throughput against developer experience, which produces more useful conversations and reduces fear-driven single-number pressure.<\/span><\/p>\n<h2><b>Proven Ways to Improve Developer Velocity<\/b><\/h2>\n<p><span style=\"font-weight: 400;\">Sustainable velocity improves when teams reduce wasted work before it reaches downstream recovery:<\/span><\/p>\n<ul>\n<li style=\"font-weight: 400;\" aria-level=\"1\"><b>Stabilize requirements early to cut rework at the source:<\/b><span style=\"font-weight: 400;\"> Rework can absorb significant software effort, and poor communication around requirements is a common cause. Reducing<\/span><a href=\"https:\/\/www.jamasoftware.com\/blog\/2018\/06\/28\/four-fundamental-requirements-management-best-practices\/\"> <span style=\"font-weight: 400;\">errors in your requirements<\/span><\/a><span style=\"font-weight: 400;\"> may be the single most effective action developers can take to improve project outcomes. Catching ambiguity before it spreads is the most useful early intervention available, because the cost multiplier on a late-caught defect dwarfs the cost of getting the requirement right the first time. Teams using AI coding agents are formalizing this discipline through<\/span><a href=\"https:\/\/www.jamasoftware.com\/blog\/what-is-spec-driven-development-sdd-for-ai-powered-engineering\/\"> <span style=\"font-weight: 400;\">spec-driven development for AI agents<\/span><\/a><span style=\"font-weight: 400;\">, where a structured spec defines what should exist before an agent generates any code.\u00a0<\/span><\/li>\n<li style=\"font-weight: 400;\" aria-level=\"1\"><b>Establish clear traceability from requirement to test:<\/b><span style=\"font-weight: 400;\"> A clear<\/span><a href=\"https:\/\/www.jamasoftware.com\/requirements-management-guide\/requirements-traceability\/what-is-traceability-8\/\"> <span style=\"font-weight: 400;\">link from requirement to test<\/span><\/a><span style=\"font-weight: 400;\"> ties a requirement back to its sources and forward to design artifacts, code, and test cases. That bidirectional chain supports impact analysis and gives teams evidence for regression testing and compliance. Traceability scores had a statistically significant relationship with cycle time and quality in an<\/span><a href=\"https:\/\/www.jamasoftware.com\/company\/press\/requirements-traceability-measured-benchmarked-for-the-first-time\"> <span style=\"font-weight: 400;\">analysis of over 40,000 projects<\/span><\/a><span style=\"font-weight: 400;\">, and top-quartile performers outperformed bottom-quartile counterparts by a factor of 2.5 in test case execution and defect detection.<\/span><\/li>\n<li style=\"font-weight: 400;\" aria-level=\"1\"><b>Shorten feedback loops with continuous integration:<\/b><span style=\"font-weight: 400;\"> Improving continuous integration maturity makes integration and regression feedback part of the development workflow, so teams can discover integration errors sooner and reduce check-in overhead. Fast, automated feedback lets us catch integration and regression problems while the work is still fresh, before a developer has to reconstruct the context from memory.<\/span><\/li>\n<li style=\"font-weight: 400;\" aria-level=\"1\"><b>Cut handoff friction between disciplines:<\/b><span style=\"font-weight: 400;\"> Delivery friction comes from the effort required to keep context aligned across boundaries when teams rely on manual coordination. Cross-discipline misalignment can compound quickly. Interface, systems, operations, and software decisions can create constraints for one another without early coordination. Practices that help include embedding architects inside development teams and setting clear expectations for PR reviews. Value stream mapping can also reveal where handoffs create delay.<\/span><\/li>\n<\/ul>\n<p><span style=\"font-weight: 400;\">Those practices work best when teams also avoid measurement habits that reward the wrong behavior.<\/span><\/p>\n<h2><b>Common Mistakes That Quietly Slow Engineering Teams Down<\/b><\/h2>\n<p><span style=\"font-weight: 400;\">Some velocity killers hide within reasonable-sounding management decisions, especially when teams tune dashboards rather than the delivery flow. Chasing a single speed metric and treating velocity as an individual measure creates related failure modes. Once a measure becomes the target, people tune the measure instead of the outcome. Code coverage targets can produce meaningless tests, and deploy-frequency targets can encourage empty deployments.\u00a0<\/span><\/p>\n<p><span style=\"font-weight: 400;\">The Satisfaction and well-being, Performance, Activity, Communication and collaboration, and Efficiency and flow (SPACE) principle measures across several dimensions in tension, so no single number can be gamed in isolation. When teams are pressured to increase velocity, they may inflate story point estimates and cut corners on quality.\u00a0<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Velocity works best as an observation about a team&#8217;s capacity. Cross-team velocity comparisons are misleading because each team calibrates story points within its own context. Stronger engineering measurement programs focus on system-level outcomes and team-level conditions, and they avoid individual output metrics entirely.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Unmanaged requirement churn creates a different blind spot. It helps to distinguish refactoring, which can be healthy, from rework, in which recently shipped code must be rewritten because the original work missed the mark. A rising rework pattern is a signal worth investigating. Delivery dashboards can hide rework, so teams relying solely on deployment metrics can have a blind spot exactly where requirements-related waste lives.<\/span><\/p>\n<h2><b>Building Developer Velocity Into Your Engineering Operations<\/b><\/h2>\n<p><span style=\"font-weight: 400;\">To make velocity easier to manage repeatably, connect delivery metrics to the specification and verification records already used during development. We may see early signals from focused improvements, especially when existing bottlenecks are obvious, but the trends that matter take longer to prove out. Delivery and experience metrics need enough time to show whether changes are producing sustainable improvement or a short-lived spike.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Repeatable velocity management combines quantitative delivery metrics with qualitative experience signals. Teams should start with controllable input metrics they can actually influence and limit the set to avoid overload. As specifications and verification carry more delivery pressure, getting <\/span><a href=\"https:\/\/www.jamasoftware.com\/requirements-management-guide\/requirements-gathering-and-management-processes\/requirements-analysis\/\"><span style=\"font-weight: 400;\">requirements clarity<\/span><\/a><span style=\"font-weight: 400;\"> right becomes the best place to focus.\u00a0<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Regulated teams that already maintain<\/span><a href=\"https:\/\/www.jamasoftware.com\/blog\/benefits-of-end-to-end-traceability\/\"> <span style=\"font-weight: 400;\">end-to-end traceability<\/span><\/a><span style=\"font-weight: 400;\"> across the lifecycle have a structural advantage here. They built the specification infrastructure everyone else is now being told to adopt.<\/span><\/p>\n<h2><b>How Jama Connect Supports Developer Velocity<\/b><\/h2>\n<p><span style=\"font-weight: 400;\">Complex, regulated product development slows when teams manage requirements and traceability across disconnected documents and spreadsheets. Jama Connect\u00ae is web-based requirements management and traceability software that keeps those records connected.\u00a0<\/span><\/p>\n<p><span style=\"font-weight: 400;\">In manual workflows, a mid-program requirement change forces someone to walk every downstream link by hand to find affected test cases and design elements. Live Traceability\u2122 addresses this failure mode by maintaining real-time <\/span><a href=\"https:\/\/www.jamasoftware.com\/blog\/how-to-overcome-organizational-barriers-to-live-requirements-traceability\"><span style=\"font-weight: 400;\">upstream and downstream visibility<\/span><\/a><span style=\"font-weight: 400;\"> and eliminating the need for periodic manual reconstruction.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">With<\/span><a href=\"https:\/\/www.jamasoftware.com\/requirements-management-guide\/requirements-traceability\/engineering-change-management\/\"> <span style=\"font-weight: 400;\">impact analysis on every change<\/span><\/a><span style=\"font-weight: 400;\">, teams can review affected work before a change ships, and compliance documentation is built as a byproduct of development. For a Systems Engineer, that means less manual traceability work across documents and spreadsheets.\u00a0<\/span><\/p>\n<p><span style=\"font-weight: 400;\">For a Test Engineer or Verification and Validation (V&amp;V) Engineer, it means linked test cases can show which requirements are covered and which tests need review when something changes upstream. For Quality and Regulatory Affairs, it means audit-ready documentation is built from the same requirements and verification evidence the engineering team uses every day.<\/span><\/p>\n<h2><b>Improve Developer Velocity Without Losing Control<\/b><\/h2>\n<p><span style=\"font-weight: 400;\">Developer velocity improves when teams manage the whole delivery system, individual coding speed alone is not enough. Clear requirements, traceable verification, and balanced metrics give leaders a way to move faster without hiding quality risk. To see how Jama Connect can help connect requirements, traceability, verification, and impact analysis in one workflow, start a<\/span><a href=\"https:\/\/www.jamasoftware.com\/platform\/jama-connect\/trial\/?utm_campaign=cta+blog\"> <span style=\"font-weight: 400;\">free 30-day trial of Jama Connect<\/span><\/a><span style=\"font-weight: 400;\">.<\/span><\/p>\n<h2><b>Frequently Asked Questions About Developer Velocity<\/b><\/h2>\n<h3><b>How is developer velocity different from productivity?<\/b><\/h3>\n<p><span style=\"font-weight: 400;\">Velocity measures how much work a team can reliably complete per sprint, which makes it a planning and predictability signal. Productivity measures how efficiently value is created per unit of effort. A team can have high velocity while producing low-value output, which is why the two should never be treated as the same thing. Use velocity for team planning instead of performance scoring. Productivity conversations should include customer value, quality, and delivery flow so teams do not chase completed work that does not matter.<\/span><\/p>\n<h3><b>What metrics best track developer velocity?<\/b><\/h3>\n<p><span style=\"font-weight: 400;\">Cycle time and lead time give a stronger view of delivery performance than story points and lines of code. The stronger approach measures across several dimensions in tension, which makes gaming harder. Start with cycle time, lead time, change failure rate, and recovery time, then compare those signals with requirement stability and test coverage. Teams working in regulated environments should also connect delivery metrics to requirements traceability so speed gains do not hide verification gaps. In Jama Connect, that link between requirements, tests, and delivery records is maintained as work changes.<\/span><\/p>\n<h3><b>Can improving velocity hurt software quality?<\/b><\/h3>\n<p><span style=\"font-weight: 400;\">Improving velocity can hurt quality when teams focus only on speed, but balanced delivery and stability metrics keep that tradeoff visible. Speed and stability can move together when teams improve the system around delivery, along with individual coding activity. The risk rises when teams adopt speed-focused tooling without process discipline, because individual activity can increase while delivery stability suffers. Fundamentals like small batch sizes and thorough testing still matter.<\/span><\/p>\n<h3><b>How long does it take to improve developer velocity?<\/b><\/h3>\n<p><span style=\"font-weight: 400;\">Teams may see early improvement from focused effort when bottlenecks are clear. Deeper trends in delivery and experience metrics take longer to become meaningful, so treat velocity as continuous improvement rather than a one-time fix.<\/span><\/p>\n<p>&nbsp;<\/p>\n<input class=\"fooboxshare_post_id\" type=\"hidden\" value=\"87228\"\/>","protected":false},"excerpt":{"rendered":"<p>Artificial intelligence (AI) coding assistants can make individual coding tasks appear faster, while organizational delivery metrics lag. The speed may show up in commits and pull requests (PRs), while customer-visible delivery stays flat. Those gains get absorbed somewhere between the individual keyboard and the production release, lost to downstream bottlenecks. Vice Presidents (VPs) and Directors [&hellip;]<\/p>\n","protected":false},"author":215,"featured_media":87230,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[1152],"tags":[838,31],"industry":[],"class_list":["post-87228","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-artificial-intelligence","tag-requirements-requirements-management","tag-systems-engineering"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v28.1 (Yoast SEO v28.1) - https:\/\/yoast.com\/product\/yoast-seo-premium-wordpress\/ -->\n<title>How to Improve Developer Velocity Without Losing Quality<\/title>\n<meta name=\"description\" content=\"Improve developer velocity with clearer requirements, traceability, and balanced metrics that protect delivery quality.\u00a0\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.jamasoftware.com\/blog\/developer-velocity\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"How to Improve Developer Velocity Without Sacrificing Quality\" \/>\n<meta property=\"og:description\" content=\"Improve developer velocity with clearer requirements, traceability, and balanced metrics that protect delivery quality.\u00a0\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.jamasoftware.com\/blog\/developer-velocity\/\" \/>\n<meta property=\"og:site_name\" content=\"Jama Software\" \/>\n<meta property=\"article:published_time\" content=\"2026-07-09T21:28:16+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2026-07-09T21:28:31+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.jamasoftware.com\/legacy\/media\/2026\/07\/How-to-Improve-Developer-Velocity-Without-Sacrificing-Quality.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1024\" \/>\n\t<meta property=\"og:image:height\" content=\"576\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Mario Maldari\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Mario Maldari\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"9 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.jamasoftware.com\\\/blog\\\/developer-velocity\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.jamasoftware.com\\\/blog\\\/developer-velocity\\\/\"},\"author\":{\"name\":\"Mario Maldari\",\"@id\":\"https:\\\/\\\/www.jamasoftware.com\\\/#\\\/schema\\\/person\\\/342c03284e4f3c09cd3938d11e3d9280\"},\"headline\":\"How to Improve Developer Velocity Without Sacrificing Quality\",\"datePublished\":\"2026-07-09T21:28:16+00:00\",\"dateModified\":\"2026-07-09T21:28:31+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.jamasoftware.com\\\/blog\\\/developer-velocity\\\/\"},\"wordCount\":2004,\"image\":{\"@id\":\"https:\\\/\\\/www.jamasoftware.com\\\/blog\\\/developer-velocity\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.jamasoftware.com\\\/media\\\/2026\\\/07\\\/How-to-Improve-Developer-Velocity-Without-Sacrificing-Quality.png\",\"keywords\":[\"Requirements &amp; Requirements Management\",\"systems engineering\"],\"articleSection\":[\"Artificial Intelligence\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.jamasoftware.com\\\/blog\\\/developer-velocity\\\/\",\"url\":\"https:\\\/\\\/www.jamasoftware.com\\\/blog\\\/developer-velocity\\\/\",\"name\":\"How to Improve Developer Velocity Without Losing Quality\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.jamasoftware.com\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.jamasoftware.com\\\/blog\\\/developer-velocity\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.jamasoftware.com\\\/blog\\\/developer-velocity\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.jamasoftware.com\\\/media\\\/2026\\\/07\\\/How-to-Improve-Developer-Velocity-Without-Sacrificing-Quality.png\",\"datePublished\":\"2026-07-09T21:28:16+00:00\",\"dateModified\":\"2026-07-09T21:28:31+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.jamasoftware.com\\\/#\\\/schema\\\/person\\\/342c03284e4f3c09cd3938d11e3d9280\"},\"description\":\"Improve developer velocity with clearer requirements, traceability, and balanced metrics that protect delivery quality.\u00a0\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.jamasoftware.com\\\/blog\\\/developer-velocity\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.jamasoftware.com\\\/blog\\\/developer-velocity\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.jamasoftware.com\\\/blog\\\/developer-velocity\\\/#primaryimage\",\"url\":\"https:\\\/\\\/www.jamasoftware.com\\\/media\\\/2026\\\/07\\\/How-to-Improve-Developer-Velocity-Without-Sacrificing-Quality.png\",\"contentUrl\":\"https:\\\/\\\/www.jamasoftware.com\\\/media\\\/2026\\\/07\\\/How-to-Improve-Developer-Velocity-Without-Sacrificing-Quality.png\",\"width\":1024,\"height\":576,\"caption\":\"Developers in discussion at monitors.\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.jamasoftware.com\\\/blog\\\/developer-velocity\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.jamasoftware.com\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"How to Improve Developer Velocity Without Sacrificing Quality\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.jamasoftware.com\\\/#website\",\"url\":\"https:\\\/\\\/www.jamasoftware.com\\\/\",\"name\":\"Jama Software\",\"description\":\"Jama Connect\u00ae #1 in Requirements Management\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.jamasoftware.com\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.jamasoftware.com\\\/#\\\/schema\\\/person\\\/342c03284e4f3c09cd3938d11e3d9280\",\"name\":\"Mario Maldari\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1741cc188e159d99f133226723afd8e169f58399139acd48b22b4645dcc6c11e?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1741cc188e159d99f133226723afd8e169f58399139acd48b22b4645dcc6c11e?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1741cc188e159d99f133226723afd8e169f58399139acd48b22b4645dcc6c11e?s=96&d=mm&r=g\",\"caption\":\"Mario Maldari\"},\"description\":\"Mario Maldari is the Technical Sales Director at\u00a0 Jama Software, where he focuses on requirements management and systems engineering solutions for regulated industries. He brings over 2 decades of experience across solution architecture, technical pre-sales, and software quality, and holds patents in traceability and structured data. Before moving into technical sales, he worked directly with engineering teams to solve compliance and requirements challenges.\",\"sameAs\":[\"http:\\\/\\\/www.jamasoftware.com\",\"https:\\\/\\\/www.linkedin.com\\\/in\\\/mariomaldari\\\/\"],\"url\":\"https:\\\/\\\/www.jamasoftware.com\\\/blog\\\/author\\\/mariomaldari\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"How to Improve Developer Velocity Without Losing Quality","description":"Improve developer velocity with clearer requirements, traceability, and balanced metrics that protect delivery quality.\u00a0","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.jamasoftware.com\/blog\/developer-velocity\/","og_locale":"en_US","og_type":"article","og_title":"How to Improve Developer Velocity Without Sacrificing Quality","og_description":"Improve developer velocity with clearer requirements, traceability, and balanced metrics that protect delivery quality.\u00a0","og_url":"https:\/\/www.jamasoftware.com\/blog\/developer-velocity\/","og_site_name":"Jama Software","article_published_time":"2026-07-09T21:28:16+00:00","article_modified_time":"2026-07-09T21:28:31+00:00","og_image":[{"width":1024,"height":576,"url":"https:\/\/www.jamasoftware.com\/legacy\/media\/2026\/07\/How-to-Improve-Developer-Velocity-Without-Sacrificing-Quality.png","type":"image\/png"}],"author":"Mario Maldari","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Mario Maldari","Est. reading time":"9 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.jamasoftware.com\/blog\/developer-velocity\/#article","isPartOf":{"@id":"https:\/\/www.jamasoftware.com\/blog\/developer-velocity\/"},"author":{"name":"Mario Maldari","@id":"https:\/\/www.jamasoftware.com\/#\/schema\/person\/342c03284e4f3c09cd3938d11e3d9280"},"headline":"How to Improve Developer Velocity Without Sacrificing Quality","datePublished":"2026-07-09T21:28:16+00:00","dateModified":"2026-07-09T21:28:31+00:00","mainEntityOfPage":{"@id":"https:\/\/www.jamasoftware.com\/blog\/developer-velocity\/"},"wordCount":2004,"image":{"@id":"https:\/\/www.jamasoftware.com\/blog\/developer-velocity\/#primaryimage"},"thumbnailUrl":"https:\/\/www.jamasoftware.com\/media\/2026\/07\/How-to-Improve-Developer-Velocity-Without-Sacrificing-Quality.png","keywords":["Requirements &amp; Requirements Management","systems engineering"],"articleSection":["Artificial Intelligence"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/www.jamasoftware.com\/blog\/developer-velocity\/","url":"https:\/\/www.jamasoftware.com\/blog\/developer-velocity\/","name":"How to Improve Developer Velocity Without Losing Quality","isPartOf":{"@id":"https:\/\/www.jamasoftware.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.jamasoftware.com\/blog\/developer-velocity\/#primaryimage"},"image":{"@id":"https:\/\/www.jamasoftware.com\/blog\/developer-velocity\/#primaryimage"},"thumbnailUrl":"https:\/\/www.jamasoftware.com\/media\/2026\/07\/How-to-Improve-Developer-Velocity-Without-Sacrificing-Quality.png","datePublished":"2026-07-09T21:28:16+00:00","dateModified":"2026-07-09T21:28:31+00:00","author":{"@id":"https:\/\/www.jamasoftware.com\/#\/schema\/person\/342c03284e4f3c09cd3938d11e3d9280"},"description":"Improve developer velocity with clearer requirements, traceability, and balanced metrics that protect delivery quality.\u00a0","breadcrumb":{"@id":"https:\/\/www.jamasoftware.com\/blog\/developer-velocity\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.jamasoftware.com\/blog\/developer-velocity\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.jamasoftware.com\/blog\/developer-velocity\/#primaryimage","url":"https:\/\/www.jamasoftware.com\/media\/2026\/07\/How-to-Improve-Developer-Velocity-Without-Sacrificing-Quality.png","contentUrl":"https:\/\/www.jamasoftware.com\/media\/2026\/07\/How-to-Improve-Developer-Velocity-Without-Sacrificing-Quality.png","width":1024,"height":576,"caption":"Developers in discussion at monitors."},{"@type":"BreadcrumbList","@id":"https:\/\/www.jamasoftware.com\/blog\/developer-velocity\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.jamasoftware.com\/"},{"@type":"ListItem","position":2,"name":"How to Improve Developer Velocity Without Sacrificing Quality"}]},{"@type":"WebSite","@id":"https:\/\/www.jamasoftware.com\/#website","url":"https:\/\/www.jamasoftware.com\/","name":"Jama Software","description":"Jama Connect\u00ae #1 in Requirements Management","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.jamasoftware.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.jamasoftware.com\/#\/schema\/person\/342c03284e4f3c09cd3938d11e3d9280","name":"Mario Maldari","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/1741cc188e159d99f133226723afd8e169f58399139acd48b22b4645dcc6c11e?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/1741cc188e159d99f133226723afd8e169f58399139acd48b22b4645dcc6c11e?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/1741cc188e159d99f133226723afd8e169f58399139acd48b22b4645dcc6c11e?s=96&d=mm&r=g","caption":"Mario Maldari"},"description":"Mario Maldari is the Technical Sales Director at\u00a0 Jama Software, where he focuses on requirements management and systems engineering solutions for regulated industries. He brings over 2 decades of experience across solution architecture, technical pre-sales, and software quality, and holds patents in traceability and structured data. Before moving into technical sales, he worked directly with engineering teams to solve compliance and requirements challenges.","sameAs":["http:\/\/www.jamasoftware.com","https:\/\/www.linkedin.com\/in\/mariomaldari\/"],"url":"https:\/\/www.jamasoftware.com\/blog\/author\/mariomaldari\/"}]}},"_links":{"self":[{"href":"https:\/\/www.jamasoftware.com\/legacy\/wp-json\/wp\/v2\/posts\/87228","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.jamasoftware.com\/legacy\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.jamasoftware.com\/legacy\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.jamasoftware.com\/legacy\/wp-json\/wp\/v2\/users\/215"}],"replies":[{"embeddable":true,"href":"https:\/\/www.jamasoftware.com\/legacy\/wp-json\/wp\/v2\/comments?post=87228"}],"version-history":[{"count":2,"href":"https:\/\/www.jamasoftware.com\/legacy\/wp-json\/wp\/v2\/posts\/87228\/revisions"}],"predecessor-version":[{"id":87231,"href":"https:\/\/www.jamasoftware.com\/legacy\/wp-json\/wp\/v2\/posts\/87228\/revisions\/87231"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.jamasoftware.com\/legacy\/wp-json\/wp\/v2\/media\/87230"}],"wp:attachment":[{"href":"https:\/\/www.jamasoftware.com\/legacy\/wp-json\/wp\/v2\/media?parent=87228"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.jamasoftware.com\/legacy\/wp-json\/wp\/v2\/categories?post=87228"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.jamasoftware.com\/legacy\/wp-json\/wp\/v2\/tags?post=87228"},{"taxonomy":"industry","embeddable":true,"href":"https:\/\/www.jamasoftware.com\/legacy\/wp-json\/wp\/v2\/industry?post=87228"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}