Top 10 Agile Database Techniques

Source –

While agile database development and management continues to gain popularity, some DBAs are still hesitant to adopt the agile method in favor of the waterfall approach. Most often this is either because some IT professionals and development teams are afraid of losing maintenance control in the constant thrust of iteration, or they’re wary of change, especially one that would require them to change the way they work together. So, here are some great techniques for having a healthy agile database:

  1. Communicate. An oldie-but-goodie, communication is one of the primary reasons why agility is sometimes rejected by DBAs; or even if they adopt it, experience unnecessary hardship. When the fast pace of agility leads to less documentation, communication techniques like the daily scrum are a great way to keep both developers and DBAs in the loop regarding bugs or any other coding issues that might affect production efficiency. Constant communication throughout the team means quicker fixes.
  1. Automate. To move quickly and efficiently, you’ll want to start automating some of your repetitive tasks. By running a build-and-test script, for example, developers won’t have to constantly check in for failed unit tests. Developers also use C#, MSBuild, MSTest, and other tools. DBA’s can automate maintenance and monitoring through SSIS packages, scripts, or SQL Server Agent jobs. Another important and satisfying automation technique is continuous integration. When all working changes and versions are automatically merged into the repository throughout the day, a lot of valuable time can be spared. This in turn sets the stage for continuous delivery.
  1. Use Source Control/Version Control. Yes, it’s a must-have for software development, but it can be very useful for database development as well. Among the many benefits of getting your database under source control, such as backup for your SQL code and more efficient integration of working versions, source control will really come in handy during database audits. Database auditors will be able to see the whole history of changes, when they were made, and by whom.
  1. Keep it Simple. It may sound obvious, but some database developers mistakenly use complex database models. Using simple models, however, can ensure data integrity and enable easier fixes and troubleshoots.
  1. Don’t Consolidate. Because you want to keep things simple, sometimes that means building separate individual systems that communicate with each other, even though you might be copying some of the coding. Consolidating all versions into one large system can sometimes end in frustration when you have to go back and make changes to adapt to a new variance.
  1. Be Consistent. It’s important to try to use patterns as much as possible when doing things such as storing procedures. If the procedures are similar, they should look similar and use similar conventions. The same goes for tables, security practices, etc. This is especially imperative when automating your database.
  1. Don’t Rush to Implement. In an agile environment, prioritizing is key. While with traditional databases developers may, for example, want to design and implement base tables as soon as possible, agile developers understand that implementing too early may risk unnecessary change later.
  1. Be Test-Driven. Using a Test-Driven Development (TDD) approach means that you write unit tests to first check that all requirements are met before writing the actual functional code. Build a full collection of automated tests and you’ll save a lot of valuable time finding errors and fixing them.
  1. Database Refactor. Understand that constructing your database schema is an iterative, incremental process. Ideally, you want to try to keep making small improvements to the schema design (e.g., triggers, data or table structures) without necessarily altering its semantics.
  1. Manage Your Time. In a dynamic environment of testing, development and deployment, make sure to set aside a little bit of time for certain tasks. Dedicating a set amount of time each week for developers to work on their deployments, for example, even if it cuts a little into development time. It leads to less technical debt and more deployments in the long run.

A lot of the anxiety some have about the agile database approach comes from fear of change, and how to deal with breakdowns and errors in such a different environment. But with the techniques above such as automating and using version control to track all errors and changes, DBAs and developers will feel much more comfortable with agility.

Notify of

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Inline Feedbacks
View all comments
Would love your thoughts, please comment.x