Liquibase Pro (legacy)

My main use case for Liquibase  is because, for our product NormaPro, we have different databases and different data schemas for each of our clients. The database, apart from the table architecture and so on, has a lot of business logic embedded within functions and procedures. Liquibase  is our main solution for new client provisioning, for deployments of the entire database architecture and all functions and procedures, to find differences between the different database schemas of our clients, and to apply updates and fixes.

Before having Liquibase, we had no control over the software that was running in each of the clients' schemas. Liquibase has provided us with a quick way to find errors in those clients where functions or procedures were outdated.

Every time we have a deployment for a new client, Liquibase, by working like GitOps for database-related matters, makes deployments and the creation of new schemas enormously easier for us.

The best features that Liquibase has are database engine abstraction, programmable code re-execution, granular deployments with contexts and labels, the automated rollback strategy and, above all, inspection and diff and baseline generation.

The rollback strategy allows us to roll back certain deployments that have gone to production with errors. In such a way that we always have a possible mechanism to roll that step back to the previous version for everything related to functions and procedures and table structure inside the database. What I like most about rollback is that we can define a rollback block directly in XML or YAML and Liquibase understands perfectly where it has to go back.

By minimizing errors, minimizing time, with an incredible cost saving, eliminating database incidents, having a diff inspector against our baseline to know which client schemas are outdated or not up to date, to know what differences there are between the different schemas, this has produced an immense cost saving for us. Before, it was very manual, very tedious work and very prone to errors. I have a metric, I have a KPI on errors produced in the database. These errors have decreased almost to zero since we have been using Liquibase.

The syntax, especially as it is agnostic, is not always 100% transparent. In heavy object management, there should be improvements, and when we have large-scale multitenant environments, the orchestration becomes a bit tedious. But basically, for my use case, it is a tool I recommend 100%.

For object management, the problem is the checksum, which has a very strict and sometimes rigid handling. Even if runOnChange is true, helping stored procedures when the code changes, any minor modification or formatting change should be a bit easier.

Liquibase flawlessly solves provisioning, maintains consistency between dozens of schemas, has database version controls integrated into Git , has enormous reliability in auditing. However, it lacks native multitenant orchestration, it has a lot of rigidity in checksum management with programmable code, and the use of native SQL within XML does not work entirely well. I give it eight out of ten because it is indispensable and unbeatable for guaranteeing consistency and automatic provisioning in our multitenant architecture. I only deduct a couple of points for the lack of native multitenant orchestration and the occasional rigidity of checksums when modifying MySQL  functions.

We have been using Liquibase for more than four years.

Liquibase is very stable.

Liquibase adapts very well to our scaling needs. I would rate it a ten.

The documentation is clear, concise, and I can find everything on their website.

We previously used migrations within NodeJS, but when the product started to scale and we had more and more clients and more schemas, the solution did not seem feasible.

Basically, what we launch is a pipeline where all the database changes are provided and Liquibase is responsible for coordinating and controlling all the schemas of all clients to apply the changes to all of them at once.

We have an ISO 27001 certification and within the specifications of the standard, we have change management where there is a specialized team for database changes, basically in charge of coordinating all movement with Liquibase. Only they are the ones who have access to this tool and to put changes into production regarding databases.

The license versus the return on investment that we have had is very substantial.

Liquibase costs us thirty-three dollars a month. Basically, in the past, before having Liquibase, finding any error in any client's database would mean hours and hours of a database expert, which would cost us much more than thirty dollars. Much, much more.

We evaluated other options. We evaluated, for example, Flyway, Redgate, and DBmaestro, but Liquibase convinced us because of the price and the direct functionality we were looking for regarding migrations.

I should not hesitate to recommend Liquibase because if you have an environment like ours, where you run many databases, each one for each client, to maintain consistency with the version that is running, it is an essential tool. Liquibase is great software that makes life and maintenance of client databases easier. I give this product a rating of eight out of ten.

My main use case for Liquibase  is currently data warehouse deployment.

For data warehouse deployment, we have a product with SQL Server , and we use Liquibase  as part of scripts for data warehouse layers with CI/CD based on a copy solution.

Another use case connected with Liquibase is application deployment; it was an application based on Oracle and SQL Server  databases, and we use Liquibase as a deployment method for both databases.

The best features Liquibase offers compared to competitors include its flexibility with the options of files that you could use for delivery, such as YAML, XML, and SQL, providing various possibilities to deliver the best script for various deployments.

The flexibility of using different file formats in my day-to-day work can be easier if I use YAML or XML files for applications, which are set up based on various RDBMS ; however, for data warehouse, SQL code is more useful because the code is much longer, based only on one database type, and that is why we use SQL for warehousing and XML or YAML file for application deployment.

Liquibase has positively impacted my organization by speeding up the deployment process in the CI/CD framework, being much more useful than different solutions for database deployment that we used before.

While we did not create any KPI for that, we notice it is much quicker, especially in application deployment when we have only two configuration files for various database setups, allowing us to deploy a new version of an application within minutes instead of hours; for data warehousing, we use a lot of variables that enable us to create dynamic stored procedures, making it feasible even without KPIs, as it saves our team from having to recreate code for various environments.

Liquibase contains most of the features that we really need in the project; however, SQL files could be extended by an additional layer of prerequisites since YAML and XML files have that option, and I believe SQL files could also benefit from having more complex prerequisites.

Regarding Liquibase's AI capabilities, I think it is secure due to the lack of SQL injection, and that suffices for that solution.

In terms of Liquibase's AI capabilities, its accuracy and reliability of output is currently very reliable for the solution that we need.

My advice for others looking into using Liquibase is that they should connect it with GitHub  actions because it is a really useful solution. I give this review an overall rating of 10.

We are currently not using Liquibase , but we have used it earlier for database deployments. I have provided product information on the PeerSpot  site.

Liquibase 's valuable features include database deployment and rollback scripts, where we kept our scripts in SQL format. When we deployed using CI/CD, it connected to Liquibase and deployed those scripts to the desired database. We integrated it with CI/CD Jenkins  to execute all Liquibase operations, and the logs were retained for around two to three months.

Liquibase's adaptive change scripts benefited our database management process significantly. Previously, if someone logged into the database, they could make changes without any information or change orders. We restricted the DB servers to the DB team specifically. Whenever they wanted to execute changes, they had to go through the change order process, and we would not provide them the password until then. We maintained complete logs so that if any database change occurred and an application stopped working, we had change orders to reference and determine whether it was a legitimate change or a normal variation.

Liquibase's rollback functionality impacted our deployment downtime positively. We would take a backup before anything was executed on the database while we had the change order. Once execution occurred, we performed sanity checks by the application team. If the checks passed, we proceeded. If not, we restored the same copy to avoid database outages.

Liquibase is a very powerful tool in terms of database automation.

I have not found many disadvantages with Liquibase. However, it does not have inbuilt rollback management. You have to take your own backup and restore it if there is any failure. It does not have a feature for rolling back or creating a snapshot of the existing database, so those things must be managed manually.

Liquibase could implement rollback compatibility in the future. Additionally, there were checksum errors, and the logs were not reporting properly in Liquibase, so those issues could be fixed.

I used Liquibase for around two and a half years.

They were helpful. We reached out via email or to their community support, and we received immediate responses.

I can rate their job an 8.5 out of 10.

I changed companies, which is why I stopped using Liquibase. The previous organization was still using Liquibase, and there was no switching of the product. However, I moved to a different organization.

I rate Liquibase a nine out of ten. We used the Community Edition for Liquibase.

We used Liquibase's changelog feature extensively. The changelog contains complete information about all the scripts we executed and presents it as event data.

Liquibase's CLI was powerful. We executed scripts through the CLI, and from CI/CD, we called those commands using the CLI.

We built a separate tool for monitoring the databases where we logged the query speed in terms of Liquibase's tracing and monitoring capabilities helping with compliance for our enterprise. We were not using any inbuilt tool from Liquibase. In terms of compliance and audit, we had the challenge that the compliance team would spend weeks gathering manual evidence for audits. We maintained change orders where we kept the change queries that we were going to execute on the production database from the DBA so that everything would be compliant because of these change orders.

My overall review rating for Liquibase is a nine out of ten.

My main use case for Liquibase  is database versioning and change set management.

A specific example of how I use Liquibase  for database versioning and change set management is that it ensures my schemas are versioned instead of losing track of them over time. Liquibase automatically rolls back changes if there are problems during a release, making the process simple.

In addition to my main use case, Liquibase has helped us solve the issue of reverting changes.

The best features Liquibase offers are the schema change sets and the change tracking on any kind of change in the database.

I definitely find that the change tracking feature makes my workflow easier.

Liquibase has positively impacted my organization by eliminating the risk around database changes.

Eliminating that risk has affected my team and business overall by removing costly downtime when trying to revert a problem deploy with a database.

I cannot think of anything at the moment regarding how Liquibase can be improved.

I am uncertain about Liquibase's AI capabilities regarding its governance and security.

I am uncertain about Liquibase's AI capabilities regarding its accuracy and reliability of output.

I have been using Liquibase for 12 years.

Liquibase is stable.

I did not previously use a different solution.

My experience with pricing, setup cost, and licensing is that it is easy since it is open source.

Before choosing Liquibase, I did not evaluate other options.

The advice I would give to others looking into using Liquibase is to make sure you read the documentation. I would rate this product 9 out of 10.

My main use case for Liquibase  is database change management inside our CI/CD pipelines. Before Liquibase , someone would have to manually run SQL scripts against the database and hope for the best.

Liquibase has positively impacted my organization by significantly increasing deployment frequency for database changes. We went from releasing database changes maybe twice a month because they were so manual and nerve-wracking to releasing them as part of every sprint.

I find it hard to put an exact number on how much deployment frequency increased, but the productivity gains are real. The manual database deployment process before involved a DBA, a developer, a change ticket, a scheduled maintenance window, and probably three to four hours of human time.

The best features Liquibase offers include the DATABASECHANGELOG table, which is deceptively simple but is the foundation of everything. Every change that has ever been applied is logged there, including who wrote it, when it ran, which environment, and the checksum.

Having that detailed tracking from Liquibase definitely helps me and my team day-to-day, making troubleshooting or audits easier.

Drift Detection is the other feature I would fight for, as the moment someone makes a manual change to a database outside the pipeline, it shows up. In a regulated environment, that is not just useful, it is necessary.

Liquibase can be improved by helping developers who have never used it before to understand change logs, change sets, contexts, and labels, which takes time. The documentation is good, but there is a gap between reading the docs and actually being confident with it.

I would appreciate more sophisticated pipeline analytics out of the box without having to set everything up manually.

I have been using Liquibase for a total of four years.

On a scale of one to ten, I rate Liquibase overall as an eight.

I rate it an eight because it fundamentally solved the problem that was genuinely painful and had not been solved well by anything else we evaluated.

Regarding Liquibase's AI capabilities, I think its governance and security are solid.

Regarding Liquibase's AI capabilities, I believe its accuracy and reliability of output could be improved.

We deploy Liquibase using GitHub Actions  and Jenkins  depending on the client environment. Liquibase itself runs as part of the pipeline job, connects to the target database, applies the pending change sets, and exits. There is no separate server to manage.

My experience with pricing, setup cost, and licensing is that the open-source version is free and genuinely capable for most use cases. We moved to Liquibase Secure for the governance features: audit logs, Drift Detection, policy enforcement, and separation of duties.