To visualize workflow metrics, teams must first gather the correct underlying data from their projects. Work item queries in Azure DevOps serve as the primary data source, pulling specific records like user stories, bugs, or tasks based on set criteria. These queries retrieve items that have transitioned through various lifecycle states, such as proposed, active, and completed. By targeting precise work item states and timeframes, these queries feed clean, accurate data directly into the dashboard configuration.
Once the queries are defined, teams display this data using specialized visual components on Azure DevOps dashboards. Cumulative Flow Diagrams track the volume of work items in each state over time, making it easy to see if work is piling up in a specific phase. Line Charts are ideal for showing historical trends, allowing teams to see if their performance is improving or declining over weeks or months. Analytics Widgets provide deep-dive calculations and pre-built metrics that reduce the need for manual calculations, transforming raw work item data into actionable insights.
Understanding the differences between flow metrics is critical for configuring dashboards correctly. Cycle Time measures the span from when a work item enters an active state to when it reaches a completed state, showing actual hands-on development speed. Lead Time begins much earlier, measuring the entire lifecycle from the moment a user submits a request to when the value is delivered to production. Time to Recovery tracks the interval between a system failure and its return to a healthy, functioning state, highlighting the system's operational resilience.
Teams use these configured dashboards to pinpoint inefficiencies and drive process changes. If a Cumulative Flow Diagram shows a widening band for testing, it signals a bottleneck where items are waiting too long for validation. Consistently high lead times with low cycle times suggest that items are sitting idle in the backlog before work actually begins. By continuously analyzing these visual trends, teams can make targeted adjustments to their workflows, reduce waste, and measure the direct impact of their process improvements over time.
The first step is to decide what to measure by setting up Key Performance Indicators (KPIs). Common KPIs for project planning include Sprint Velocity, which shows how much work a team finishes in a sprint; Cycle Time, which tracks how long a single work item takes from start to finish; and Backlog Health, which gives a snapshot of how many items are waiting and their priority. These metrics help the team understand their pace, identify delays, and manage future workload.
To get the data for these KPIs, you write queries using Work Item Query Language (WIQL), the special query language used in Azure DevOps to find and filter work items like user stories, bugs, and tasks. Authoring a query means using the WIQL syntax to ask for specific work items, such as all tasks completed in the last sprint to calculate velocity. You filter data using fields like Work Item Type, State, and Changed Date. Optimizing a query makes it run faster and use less resources by simplifying query logic, filtering on fields that Azure DevOps has indexed for speed, and only requesting the data columns you actually need for your report or dashboard.
The final step is to turn the query results into easy-to-understand visuals. You can implement dashboards within Azure DevOps to display charts and graphs for your KPIs. For example, a velocity chart shows trends over multiple sprints, while a cycle time report can highlight bottlenecks. These dashboards pull data from your optimized WIQL queries to provide a central place for the whole team to see project health, track progress against goals, and support decisions with real data.
Development telemetry tracks how your application behaves and performs while developers are building and testing it. Azure provides two main tools for this: Azure Monitor and Application Insights. Azure Monitor collects data from your cloud and on-premises resources, while Application Insights focuses specifically on how your application code performs. Together, these tools help teams find problems before users encounter them.
KPIs tell you whether your application is working well. Response Time measures how long the app takes to answer a request, which matters most for user experience. Error Rate counts problems that occur over time, so you know when something breaks. Resource Utilization watches CPU, memory, and network usage to prevent slowdowns caused by overloading your servers.
To collect telemetry data, you create a diagnostic setting that sends logs to an Azure Log Analytics workspace where you can query them. You can also use resource-specific logging to tailor what you capture—for example, an AKS cluster can send only the logs that matter for containerized apps. Azure Monitor offers different log collection tiers, so you can save money by using basic logs for data you rarely query and full logs for important diagnostics.
Application Insights is built specifically for monitoring application code. Enabling workspace-based Application Insights gives you better tools for controlling costs. When your app generates too much telemetry data, use sampling to keep only a representative portion while still getting accurate metrics. You can also preaggregate metrics, which combines numbers before sending them to Azure, reducing the amount of data that travels over the network.
Kusto Query Language (KQL) lets you search and analyze the telemetry data that Azure collects. Start your queries with the where operator to filter data early—this makes your query run faster because it processes less information. When searching text, prefer has over contains because has is quicker. If you use the same calculation multiple times in a query, use the materialize() function with a let statement so Azure calculates it once and reuses the result.
Once you have telemetry flowing, create custom metrics and log tables that match your application's specific needs. Run KQL queries regularly to surface performance problems and check whether your build pipelines are stable. Set up alerts that notify your team when telemetry crosses certain thresholds, so you can fix issues before they affect users. This cycle of collecting data, analyzing it, and responding to what you find keeps your application running smoothly.
The most important metrics to track focus on the health and effectiveness of your tests. The Test Success Rate shows the percentage of tests that pass, giving a quick view of overall stability. Code Coverage measures how much of your application's code is actually run during tests, which helps find untested areas. Test Duration tracks how long tests take to run, which is important for keeping your development pipeline fast. Monitoring Failure Trends over time helps you spot if a problem is a one-time issue or a growing pattern that needs deeper investigation.
To gather these metrics, you must add instrumentation to your testing process. Within Azure Test Plans, you can configure settings to collect data on test runs and outcomes. For applications, you integrate Application Insights to automatically capture performance data and exceptions during test execution. This setup provides the raw data needed for analysis.
Once data is collected, you use Kusto Query Language (KQL) to examine it. You write KQL queries to filter, summarize, and analyze the test results stored in services like Application Insights. For example, a query could calculate the average test duration for the last week or list all failed tests from a specific build. These queries turn raw data into actionable information.
The final step is to present the information clearly. You can build dashboards in Azure Monitor to display the results of your KQL queries as charts and graphs. These dashboards give teams a real-time, visual snapshot of test health, which can be monitored during development or displayed in release pipelines to gate deployments. Good visualization makes complex data easy to understand and supports faster, data-driven decisions.
Azure provides several services that generate security data, and knowing which ones to watch is the first step in building good monitoring. Azure Key Vault tracks who accesses your secrets and keys, which matters because leaked credentials cause many breaches. Azure Policy watches your resources and flags any that do not meet your security rules, such as storage accounts allowing public access.
Microsoft Defender for Cloud scans your environment for threats and sends alerts when it finds suspicious activity, like unusual login attempts or malware. Azure Monitor Logs collects the raw data from all these services into one place where you can search and analyze it. Together, these sources give you a complete picture of your security posture.
Once you know where the data comes from, you need tools to make sense of it. A Log Analytics workspace acts as a central repository that gathers logs from all your Azure resources so you can query them together. Kusto Query Language (KQL) lets you write queries that sift through millions of log entries to find security issues, such as failed login attempts from foreign IP addresses. You can combine KQL with Log Analytics to build interactive dashboards that update in real time as new data arrives. Alerts work alongside queries to notify you immediately when something suspicious happens, rather than waiting for you to check the dashboard.
Dashboards turn raw data into something you can act on quickly. Azure Dashboards let you combine charts, graphs, and log queries into a single view that shows your security health at a glance. Workbooks go further by letting you add explanatory text alongside your metrics, which helps team members understand what they are looking at without needing deep technical knowledge. Setting up alerts through Azure Monitor ensures that critical issues reach the right people fast, whether through email, SMS, or integration with incident management tools. The goal is to have a clear picture of your security state without requiring constant manual checking.
Effective security monitoring requires ongoing attention and the right tools. Enable threat detection on all critical services; for example, Microsoft Defender for SQL watches database queries for patterns that suggest attacks. Review security recommendations from Microsoft Defender for Cloud regularly, because they reflect the latest threat intelligence and Azure best practices. Use metric dimensions to add context; for example, tracking total failed logins matters, but knowing which user accounts fail most often tells you whether a specific account is compromised. These practices help you detect threats faster and prove to auditors that you maintain proper security controls.
To understand the health of a delivery pipeline, teams must track specific performance indicators. These indicators help show how fast a team can deliver value and how stable their software is in production:
Teams configure Azure DevOps analytics queries and Azure Monitor dashboards to visualize these indicators. Analyzing these results helps teams identify bottlenecks and prioritize where to make process improvements.
Tracking these metrics requires setting up proper data collection and log analysis tools. Using Log Analytics workspace insights, teams can run queries to find trends in their deployment data and identify slow workflows. Enabling log query auditing helps teams find and rewrite inefficient queries that might otherwise slow down their monitoring dashboards. For applications running in Kubernetes, monitoring must cover every layer of the environment. Teams use Container insights alongside Azure Monitor managed service for Prometheus to gather metrics from the network, cluster, and application layers. This data flows into centralized dashboards, allowing teams to build proactive alerts and identify system anomalies before they impact users.
Managing delivery metrics also requires balancing performance, cost, and security across all monitoring tools. High-volume logging can quickly become expensive, so teams should configure cost optimization settings to filter out unnecessary telemetry data. This ensures the team only stores the high-value logs needed to calculate their core delivery metrics. For the data tier, teams must monitor performance and security without introducing overhead. A tool like Database watcher helps track database health, while recommendations from SQL Database Advisor guide teams on how to secure and optimize their databases. This end-to-end monitoring ensures that both the delivery pipeline and the underlying database systems remain fast, secure, and cost-effective.
Azure Monitor gathers a wide set of performance metrics from services such as SQL Database, virtual machines, and app services. Query Performance Insights in SQL Database shows which queries consume the most resources and can recommend index changes or query rewrites. SQL Database Advisor can apply those recommendations automatically, so performance improves without manual effort. By tracking metrics like CPU, memory, and request latency, you can spot bottlenecks and decide when to scale or tune a service. Automation of routine tuning tasks reduces manual work and keeps applications running efficiently.
Azure Monitor also helps protect your environment by detecting threats and scanning for vulnerabilities. Threat detection in SQL Database alerts you to suspicious activity such as unusual login patterns or SQL injection attempts. A vulnerability assessment tool scans databases for misconfigurations and known weaknesses, then provides step-by-step remediation steps for each finding. These features generate security recommendations and compliance reports, which you can review in the Azure portal to maintain security standards and meet regulatory requirements.
Using historical usage data, Azure Monitor can suggest ways to reduce spending. For SQL Database, recommendations include moving to elastic pools, which let you share resources among multiple databases and pay only for the pool’s total capacity. Azure Monitor’s cost analysis tools track resource consumption over time, making it easier to identify underused or overprovisioned resources. Following these recommendations helps you manage budgets while still meeting performance needs.
The Database watcher service collects deep telemetry about database performance, configuration, and health, then presents it in a unified dashboard for your entire Azure SQL estate. Metrics Explorer lets you chart multiple metrics on a single graph, compare them over time, and filter by resource or dimension. Dashboards and Workbooks are customizable reports that combine metrics, logs, and visualizations for at-the-glance monitoring. You can also set alerts that fire when a metric crosses a threshold, and send notifications or trigger automated responses. For advanced visualization, Azure Monitor integrates with tools like Grafana and Power BI, so teams can build operational dashboards tailored to their workflows.
Kusto Query Language (KQL) is the query language used in Azure Monitor to analyze log data. With KQL you can filter, aggregate, and join records from multiple sources, making it possible to investigate performance issues, correlate events across services, and identify trends that precede failures. These queries are saved and reused, and they feed directly into Log Analytics workspaces for deep analysis. By authoring KQL queries, operations teams can respond proactively to anomalies before they become outages, supporting faster incident resolution and continuous improvement of DevOps pipelines.
Seeking the thrill of transformative tech? Explore the art of designing and implementing DevOps solutions on Azure. Master the shift towards CI/CD, testing, and delivery, while preparing for the Designing and Implementing Microsoft DevOps Solutions exam!
Prepare and test your skills
Prepare and test your skills
Cycle time measures the span from when a work item enters an active state to when it reaches a completed state, showing actual hands-on development speed. Lead time begins much earlier, measuring the entire lifecycle from the moment a user submits a request to when the value is delivered to production.
Key performance indicators for development telemetry include response time, which measures how long the app takes to answer a request; error rate, which counts problems that occur over time; and resource utilization, which watches CPU, memory, and network usage. These KPIs are tracked using tools like Azure Monitor and Application Insights.
Optimizing a WIQL query makes it run faster and use less resources by simplifying query logic, filtering on fields that Azure DevOps has indexed for speed, and only requesting the data columns you actually need for your report or dashboard. This process transforms raw work item data into actionable insights for metrics like sprint velocity.
StudyCerts
StudyCerts