I'm one of the founders of NetGreener, an AI efficiency platform we're launching soon.
As more teams deploy AI applications using Azure OpenAI and other AI APIs, monitoring costs and resource consumption at the application level is becoming increasingly important.
Cloud billing tells you what you spent, but it doesn't always explain which agent, workflow, or code path caused that spending.
That's where NetGreener comes in.
We're helping teams:
Track AI/API costs by application, agent, and code path.
Monitor CPU, GPU, memory, and resource consumption.
Detect unnecessary API calls, retries, and inefficient workloads.
Estimate energy consumption, carbon emissions, and water usage.
Identify optimization opportunities and verify actual savings.
Monitor efficiency throughout development and CI/CD workflows.
NetGreener supports Python applications, with Node.js integration being expanded, and provides developer tools for VS Code, Cursor, etc.
We're looking for Azure-based development teams willing to test NetGreener on real AI workloads.
š $1,000 in free NetGreener platform credits to get started.
š Another $1,000 in credits for useful feedback, bug reports, or improvement suggestions.
I'd also be happy to personally help you or your team integrate NetGreener and set up monitoring. We can arrange a quick call if needed.
I am struggling to show on ADO dashboard how many user stories were carried forward from Sprint 1 to Sprint 2.
Our iteration paths are Sprint 1 and Sprint 2, so it gives me all User Stories in Sprint 2, but some stories were created for sprint 2. I donāt want the combine stats.
I am currently setting up a fully air-gapped (offline) Azure DevOps Server on Windows Server 2025, backed by a dedicated SQL Server instance. The environment is still in the development phase.
When attempting to apply the latest security patch, the installation fails with the following error:TF246017
Looking at the logs, this happens specifically when the patch triggers the tfsconfig.exe process on the background (for example, while trying to update feature flags). The patch is being executed by an admin account that does not currently have high-level SQL privileges.
From my research and the Microsoft documentation, it appears that the account executing the patch strictly requires the SQL sysadmin server role, and that a standard db_owner role is insufficient for tfsconfig.exe to do its job.
Can anyone confirm if the sysadmin role is indeed a hard requirement for applying ADOS patches? And if so, how do you handle this in strictly regulated environments? Do you grant it temporarily just for the maintenance window?
Iām currently writing my masterās thesis at FH Dortmund (in Germany) on generative AI in everyday work, focused in the IT branch, and how theyāre actually changing daily work: productivity, collaboration and data protection. In both office and remote.
Since this sub is all about DevOps and Azure, I think the perspective of specialists with a professional background is especially VALUABLE, whether you use AI tools yourself or consciously choose not to.
I would kindly ask your permission to post a small survey to assist my academic research (it has no other porpouses but academic ones). It takes about 10 minutes, is completely anonymous and available in German and English:
Hi all. I have worked with Azure Boards for years, and some things always took too many clicks or a hand-written query. So I built Flowboards, a free extension (MIT license, no paid version). Full disclosure: I am the author.
What it adds:
- **A forecast with a date.** Monte Carlo from your team's real pace, for example "85% likely by 14 Nov".
- **A Feature's stories across the board.** Pick a Feature and its stories light up in every column. Drag a story onto another Feature to change its parent.
- **Column rules.** "Active needs a task", "Only the product owner may close it". A rule stops the move and lets you fix it on the spot.
- **Backlog search that keeps the tree.** Every match keeps its Epic and Feature around it.
- **A dependency map.** What is blocked and by what, with loops flagged.
- **A roadmap that says what will be late.** Each Epic and Feature gets a "likely done by" date.
- **Recurring stories.** The weekly review or the release checklist, with tasks and a rotating owner.
- **Pull request times per team.** Wait for the first approval, time to merge, and who each one waits on now.
- **Tag tidying.** Finds look-alike tags, then merges, renames or deletes them.
- Also a story map, sprint planning with capacity, retros, planning poker and health checks.
It runs in your browser with your own sign-in: no server, no token to paste. It only reads pull requests and can never change code. It works with Azure DevOps Services, not Azure DevOps Server.
AZPR reads the source at the PRās commits without checking out the repository, configuring an MCP server, or adding a CI pipeline. You use the models configured in OpenCode.
The workflow I recommend is:
Run /pr-review <PR URL> --preview to review the PR and prepare comments without posting them.
Inspect the findings, exclude any you donāt want to publish, or change their severity. The model generates a new comment preview without rerunning the review.
Read that preview, then explicitly publish the saved comments. Eligible high- and medium-severity findings can become inline comments; low findings stay in the PR summary.
Review and deep modes use functional and risk reviewers followed by separate model verification against the source. Recent updates also changed how severity is assessed: concrete harm and realistic triggers determine priority, and repeated mistakes are reported separately when each location needs its own fix.
I wanted evidence beyond a demo, so I compared 12 model and reasoning-effort configurations on Martianās open Code Review Bench: 50 real PRs from cal.com, Discourse, Grafana, Keycloak, and Sentry.
One useful result: more reasoning effort didnāt consistently improve the overall score. With Claude Opus 5.5 across all three review roles, medium and high effort produced similar F2 scores in the initial comparison: 51.6 versus 51.2. High found more reference issues but had lower precision. Extra-high effort produced more findings and a lower F2 score. That comparison used Claude Opus 5.5 as the judge; each configuration ran once.
I then scored the selected medium-effort /pr-deep run using the benchmark pipeline and the dashboardās default judge, Claude Opus 4.5:
67.7% recall over 158 core reference issues
74.2% recall on High and Critical issues
30.0% benchmark precision
54.1 F2
Compared with the 21 tools displayed in the dashboardās Core view in our November 6 snapshot, that run would have the highest recall and place sixth by F2. These are self-run results; AZPR is not an official leaderboard entry.
The trade-off is more findings to triage. Unmatched issues count against benchmark precision even when they describe valid problems, but additional comments still require a reviewerās attention. The preview and adjustment steps let you decide which findings are worth posting.
The benchmark used a local Azure API adapter to serve the GitHub PRs and did not exercise comment planning or publication. All 12 configurations, the scoring method, and limitations are documented here:
AZPR 0.3.5 is tested with OpenCode 2.2.4 on Ubuntu 22.04 / WSL2. Setup requires a tool-capable model and an organization-scoped Azure DevOps PAT. Source context goes to your configured model providers, and reviews and previews can incur charges or consume subscription usage. This is an independent community project, not affiliated with the OpenCode team.
For people reviewing Azure DevOps PRs: would you prefer more candidate findings to inspect, or fewer findings with a stricter cutoff? Iād also appreciate feedback on the setup and preview/publish workflow.
We've many projects that are very similar because they were created from templates. Whenever we have to make non-functional changes related to the project setup, that means updating a few dozens of repositories with the same changes. To speed things up, I've written a small extension that helps to perform bulk changes across a large number of repositories - either through direct commits or pull requests.
Identical changes across many repositories like adding a file, moving/renaming a file, deleting files, etc. - also entire git commit diffs can be applied
Previewing changes before actually committing them (directly or via pull request)
Tracking previous bulk changes (currently the history is scoped per user and limited to 100 entries per user)
Common use cases we use it for:
When working with project templates, apply similar changes made to the template to all the projects created from the template.
Update pipelines
Update dependencies (like NuGet, etc)
Update common artifacts like Dockerfiles, dev-tool configs (e.g. ESlint), etc.
Add new artifacts like a Renovate config
... and all the other things one does not like to perform dozens of times by hand
Worth noting: the extension runs entirely in the browser and has no external dependencies or connections. Each user can perform the actions they already can perform manually, since the extension uses the exact same APIs with the same permissions. However, as a full disclaimer, the tool obviously makes it possible to cause harm more easily through bulk operations. It does not replace proper policy setups - in fact, it is strongly encouraged to use it with proper pull request policies to improve the overall workflow and confidence in the changes.
I am curious how teams manage the handoffs between IT support and the dev teams.
When somebody reports an issue through ServiceNow, it might turn out to be a product bug that the engineering team needs to investigate in Azure DevOps.
I am wondering whether it's better to automatically create an Azure DevOps work item for every qualifying incident or have someone review it first.
A few things I am curious about:
Do you have rules to decide which incidents become development bugs?
How do you avoid creating multiple bugs for the same underlying issue?
Do you sync status and comments between ServiceNow and Azure DevOps?
When a bug is fixed, should the original ServiceNow incident close automatically?
For those who have connected these systems, what approach has worked the best? Has automation made things easier, or introduced new problems?
Had a weird one with a scheduled analytics rule in Sentinel. The KQL returned the expected DeviceProcessEvents, but no alert showed up in SecurityAlert. Now I'm wondering how many other rules look fine when we test the query but fail when the scheduler runs them.
We've been replaying a few techniques with Atomic Red Team and checking the results by hand. It's manageable for a handful of rules, but not much fun when a parser or query changes.
I'm considering Cymulate for repeat detection tests, though I haven't worked out how much it can check in Sentinel itself versus what we'd still need to verify manually.
How are you handling this? Are you testing the full path from endpoint event to alert and incident, or mostly validating the KQL and checking the logs afterward?
A made-up multi-stage YAML pipeline with six steps. Assume reviewer attention is limited, so only two of them can have a manual approval. Think about it before reading my answer.
Run the tests
Build and publish the artifact
Deploy to a staging environment
Run the database migration against production
Deploy to a production environment
Post a ārelease doneā notification
Questions Iād ask of each step:
If itās wrong, how hard is it to undo?
Would anyone notice without being told?
How much does a reviewer need to know to judge it?
How often does it run?
My answer
Tests, build, staging, notification: no approval. Failures show up on their own, and staging exists for mistakes.
Production migration: yes. Itās the hardest to undo and can fail quietly. The reviewer should see what will change (the script, the affected tables, a dry run), and the approval request can carry that in its instructions to approvers.
Production deploy: depends. With a tested rollback, a canary or a feature flag, plus monitoring, Iād lean on those. If it touches money, access or data deletion, or has no tested rollback, Iād gate it.
What Azure DevOps offers, as far as I know (check your organization, names and options can vary):
Environments with Approvals and checks: a manual approval is configured on the environment, and a deployment job that targets it waits there.
Other checks on the same environment: branch control (only deploy from certain branches), business hours, querying Azure Monitor alerts, invoking an Azure Function or REST API, and exclusive locks so two deployments donāt run at once.
Checks on other protected resources: service connections, variable groups and secure files can also have approvals and checks.
Instructions to approvers: put the link to the diff or the dry-run output there, so the reviewer sees the effect and not just āapprove?ā.
Why not approve everything: when nearly every approval is fine, people learn to click without reading. It helps to track how often approvals are rejected. A gate that never rejects may mean a good pipeline or a review that isnāt catching anything.
Caveats: this is my reading of how to use the features, not an official recommendation. Detectability is easy to overestimate, regulated settings may require named sign-off regardless, and volume changes how well a gate holds up.
Which two would you pick, and which checks do you use in practice?
Have you ever found yourself switching back and forth between the source and preview mode while reviewing a markdown file? If yes, you can try this extension for a more seamless markdown read/review experience: