Voice of the DBA

Tag: DevOps

  • Measuring Productivity

    I’ve dealt with a lot of customers with who lately are concerned with the ROI of their teams. Certainly they want a good ROI if they purchase software from Redgate, as do we. Our goal has been to be partners with customers and continue to add value to the products they’ve purchased on a regular basis. We release every week or two, and our Redgate Monitor and Flyway updates reflect this. New functionality, fixes, and previews. I’m proud of the constant updates we deliver, and I know customers get increased value throughout our partnership.

    Does our software provide a good ROI? I get asked this question by execs regularly, and I often ask them if they feel they get a good ROI from their staff already. Answers are mixed, especially in the database world where it seems the costs and the value delivered from database dev or ops groups can be nebulous. Databases support application software, and if that software doesn’t work well because the database deployment scripts weren’t correct, weren’t tested, or have performance issues, who is at fault?

    It’s easy to blame the database, but who bears responsibility here? Is it the developers that didn’t model schema well or test queries at high volumes of data? DBAs who haven’t been adding or maintaining indexes? A lack of resources matching workload (an Ops issue)? Perhaps someone not taking time to review code (shared Dev/Ops or process issue) is at fault. Could it be the delays from a slow process to deploy changes end up delaing your digital transformation? Execs really care about that last one.

    There are metrics that DORA produces from their research around software delivery. These can be applied to database code, though I find often that companies adopting these don’t extend them to the database. At Redgate, we often have solutions engineers and architects spending time helping customers evaluate their existing database software lifecycle and try to decide if there is room for improvement. We love to sell you software, but only if you will use it and get value from the purchase.

    Today I’m wondering if any of you self-assess and maintain metrics or measures about how your databases perform. Lots of you use Redgate Monitor (or some other software) to watch databases, but do you keep metrics on how code gets to production? DORA would recommend you measure the time to make a deployment, the frequency, and other items, including when deployments fail. By the way, code compiling, but breaking the application because the logic is wrong is still a failed deployment.

    In 2026, even in the age of AI, I’m surprised how often I run into companies still doing manual work to deploy database code. Emailed scripts, file shares with random collections of code, even manual runs of SQL Compare to update production are the norm in many places. Even when C#/Java/etc. application code runs through an automated CI/CD process. I get that stateful databases are hard, but shouldn’t we be trying to make changes easy? An ordinary event, not an extraordinary one?

    Maybe more importantly, do you measure yourselves and evaluate your productivity as a DBA or database developer? Whether you do or don’t, what do you think are good measures of your productivity?

    Steve Jones

    Listen to the podcast at Libsyn, Spotify, or iTunes.

    Note, podcasts are only available for a limited time online.

  • Architecting Zero Downtime Deployment Resources–Albany Day of Data

    Thanks to those who attended my session at Day of Data Albany 2026. I’m posting this to help you find the resources from the talk.

    Slides: ArchitectZeroDowntime_SQLSatAlbany2026

    GitHub Repo: https://github.com/way0utwest/ZeroDowntime

    The GitHub repo has the code for the database setup and demos (and teardown) in the SQL folder. This creates the db, login/user, schema, and data.

    The VS project is in the DBClient folder. I don’t think this is updated beyond .Net 4.6 (?), but feel free to update it. There isn’t anything special about this project. It was developer in VS 2019, but I ran it from VS2022 on Saturday, and I believe I upgraded my local project to .NET 4.8 last week. I haven’t committed this back as I don’t want to push this forward yet.

    If you have questions, feel free to contact me.

  • Finding Bad Queries

    T-SQL Tuesday #200 was in July, hosted by Brent Ozar, and it was a great topic: How do you recognize a bad query? In the age of AI, when lots of people will get queries written by others (people or AIs), how can you easily and quickly review code? Review is already a challenge in the software world, and I am sure it’s going to be even more challenging as people let machines author more database code.

    Lots of you might hope that an AI agent will write better code than your average developer, but I don’t know if I’d count on that. There is a ton of poor query examples on the Internet and that’s where AI models are trained. You need some sort of feedback loop, good testing, and strong guidance if you want better query code. I think it’s as likely as not that AIs will produce poor queries just like humans.

    Just faster.

    How can you recognize poor queries? How do you judge if there are issues? Brent’s roundup shows what a number of people think, and there are some good “quick checks” to use to evaluate your code. The things that people wrote in their blog posts are the types of things that I’d want added to Flyway’s Code Analysis rules to catch problems before they get deployed to production. After all, anything that gets to production usually lives for 10 years (my rule of thumb).

    Getting feedback early in the development process is critical. We know from over 50 years of software development that finding problems early is less expansive than finding them later. Whether we use humans or AI agents, we don’t want unnecessary time spent on simple bad code things that we know cause issues. Shift-left is still a challenge, even in the automated era of DevOps and guided AI agent skills. We need reliable, repeatable ways to analyze code and limit the downstream effects of poor quality.

    Especially these days, where the volume of changes is overwhelming CI/CD systems. This was a problem already in organizations with too many teams in one codebase. It’s a growing problem in more organizations as users use AI and submit more changes.

    Plus wasting time gets expensive. Human labor is slow and spending time on more tokens for rework gets expensive.

    Don’t let bad queries flow through to CI/CD systems if you can avoid it. Learn to provide quick feedback early to whoever, or whatever, writes your SQL.

    Steve Jones

    Listen to the podcast at Libsyn, Spotify, or iTunes.

    Note, podcasts are only available for a limited time online.

  • Working Better Under Pressure

    One of my colleagues wrote a great post about DBAs and developers, about how a DBA’s pushback on bad code isn’t to be difficult, it’s because they can see the future. I never thought of myself as a modern-day Nostradamus, predicting the future of system performance. Apparently I had another title besides DBA.

    Working under pressure and with short deadlines often leads to short cuts. I’ve made them. I’ve implemented quick hot fixes. I’ve forgotten to port changes back to development databases. I’ve increased our tech debt load, just to solve a more immediate problem.

    The challenge is cleaning things up later, when we have more deadlines and things to fix. It seems that we never have enough time to do the job the way we would like, and there’s certainly no time to go back later and fix things. Most management won’t make this a priority until things get so bad that we have to rewrite a lot of code (which we should never do).

    DevOps, pipelines, automations, and yes, AI, helping can reduce some of the tech debt we create if we use those tools appropriately. Which is a big IF. Often we have more immediate pressures that prevent us from finding time to invest in our systems or in ourselves.

    Getting a handle on bad code, checking it early, and doing so every time with automation can help prevent some of these issues, even when we are in a hurry. That’s why it pays to adapt our work and learn from others. Listen to that DBA that keeps your systems alive. Listen to the DevOps engineers that want you to automate things. Certainly, make them prove their suggestions work, but adopt those patterns. Learn to work with them, rather than against them.

    They can see the future.

    Steve Jones

    Listen to the podcast at Libsyn, Spotify, or iTunes.

    Note, podcasts are only available for a limited time online.