Managing database schema changes efficiently is essential for maintaining application stability and ensuring smooth deployments. .NET Core provides multiple tools for handling migrations, each with its own advantages and drawbacks.

In this article, we’ll compare Entity Framework (EF) Core Migrations, DbUp, FluentMigrator, and Liquibase, evaluating them based on:

🔹 Simplicity – Ease of setup and usage.
🔹 Ease of Use – Developer experience when creating and applying migrations.
🔹 Speed of Development – How quickly schema changes can be applied.
🔹 Known Problems – Common challenges and limitations of each tool.

1. Entity Framework Core Migrations

💡 Best for: Applications using EF Core ORM that need automatic database migrations.

EF Core Migrations enables developers to manage schema changes through C# migration scripts rather than raw SQL.

How It Works

🔹 Define models in C#.
🔹 EF Core compares model changes and generates migrations.
🔹 Run dotnet ef migrations add <name> to create a migration.
🔹 Apply changes using dotnet ef database update.

Setup

1. 1. Install EF Core CLI tools: dotnet tool install --global dotnet-ef
2. 2. Add the EF Core NuGet package: dotnet add package Microsoft.EntityFrameworkCore.SqlServer
3. 3. Create a migration: dotnet ef migrations add InitialCreate
4. 4. Apply migrations: dotnet ef database update

Pros & Cons

✅ Pros	❌ Cons
Fully integrated with EF Core	Harder to manage complex migrations
Auto-generates SQL for schema changes	Not ideal for raw SQL-based modifications
Easy rollback support	Can be slow for large databases
Works with multiple database providers	Limited control over migration scripts

Known Problems

🔹 Generated SQL may not be optimal – The automatic SQL script can sometimes be inefficient, requiring manual optimization.
🔹 Migrations can get out of sync – If different team members modify models but forget to add migrations, EF Core can generate conflicting scripts.
🔹 Renaming tables/columns can cause data loss – EF treats renames as drop-and-create operations unless explicitly handled with RenameColumn or RenameTable.

Verdict

🔹 Simplicity: ⭐⭐⭐⭐☆ (Easy for EF Core users)
🔹 Ease of Use: ⭐⭐⭐⭐☆ (Good for ORM-based applications)
🔹 Speed of Development: ⭐⭐⭐⭐☆ (Quick for model-first workflows)

2. DbUp

💡 Best for: Developers who prefer raw SQL migrations with version tracking.

DbUp is a lightweight migration tool that runs SQL scripts in sequence and tracks which ones have already been applied.

How It Works

🔹 Write SQL scripts (.sql files).
🔹 DbUp logs applied scripts in a database table.
🔹 Runs new scripts on application startup or manually via a runner.

Setup

1. 1. Install the NuGet package: dotnet add package DbUp
2. 2. Create a migration runner:

var upgrader = DeployChanges.To
    .SqlDatabase("YourConnectionString")
    .WithScriptsFromFileSystem("Migrations")
    .LogToConsole()
    .Build();

var result = upgrader.PerformUpgrade();

Pros & Cons

✅ Pros	❌ Cons
Simple and flexible	No built-in rollback support
Full control over SQL	No automatic schema generation
No ORM dependency	No explicit migration structure
Good for database-first projects	Requires manual tracking

Known Problems

🔹 No rollback mechanism – If a migration fails, rolling back requires manually writing a reverse SQL script.
🔹 Manual script tracking – Developers must ensure scripts are numbered properly to avoid duplicate executions.
🔹 Schema drift risk – Since it’s SQL-based, developers might make changes outside of migrations, leading to inconsistencies.

Verdict

🔹 Simplicity: ⭐⭐⭐⭐⭐ (Very simple, pure SQL)
🔹 Ease of Use: ⭐⭐⭐⭐☆ (No ORM overhead, but manual tracking)
🔹 Speed of Development: ⭐⭐⭐☆☆ (Slower than EF Core for model-first workflows)

3. FluentMigrator

💡 Best for: Developers who want code-based migrations without using EF Core ORM.

FluentMigrator enables structured C#-based migrations using a fluent API, providing more control than EF Core while avoiding raw SQL.

How It Works

🔹 Define migrations in C# classes instead of SQL.
🔹 Use a fluent API to describe schema changes.
🔹 Run migrations via CLI or integrate into application startup.

Setup

1. 1. Install FluentMigrator: dotnet add package FluentMigrator.Runner
2. 2. Define a migration
3. 3. Run migrations: dotnet ef migrations update

[Migration(20250301)]
public class AddUsersTable : Migration
{
    public override void Up()
    {
        Create.Table("Users")
            .WithColumn("Id").AsInt32().PrimaryKey().Identity()
            .WithColumn("Name").AsString(255).NotNullable();
    }

    public override void Down()
    {
        Delete.Table("Users");
    }
}

Pros & Cons

✅ Pros	❌ Cons
Code-based migrations (no SQL required)	Learning curve for fluent API
Database-agnostic	Requires manual execution setup
Supports rollback	Slower than raw SQL execution
Good for large teams	Requires writing migration tracking manually

Known Problems

🔹 Steep learning curve – The fluent API syntax can be hard to grasp for developers used to SQL.
🔹 Migration history maintenance – Developers must ensure proper ordering and dependency handling.
🔹 Limited built-in tooling – Unlike EF Core, FluentMigrator doesn’t provide integrated database management commands.

Verdict

🔹 Simplicity: ⭐⭐⭐☆☆ (More complex than EF Core)
🔹 Ease of Use: ⭐⭐⭐⭐☆ (Structured, but not automatic)
🔹 Speed of Development: ⭐⭐⭐☆☆ (Slower than EF Core for small projects)

4. Liquibase

💡 Best for: Teams managing large-scale databases with version-controlled SQL scripts.

Liquibase is a cross-platform migration tool that allows defining schema changes in SQL, XML, YAML, or JSON formats.

How It Works

🔹 Define schema changes in ChangeLog files.
🔹 Track applied migrations in a database changelog table.
🔹 Execute migrations via CLI or integrate into CI/CD pipelines.

Setup

1. 1. Install Liquibase CLI: brew install liquibase
2. 2. Create a changelog.xml
3. 3. Apply migrations: liquibase update

<databaseChangeLog>
    <changeSet id="1" author="dev">
        <createTable tableName="Users">
            <column name="Id" type="int" autoIncrement="true">
                <constraints primaryKey="true"/>
            </column>
            <column name="Name" type="varchar(255)"/>
        </createTable>
    </changeSet>
</databaseChangeLog>

Pros & Cons

✅ Pros	❌ Cons
Supports multiple formats (SQL, XML, JSON)	Requires Liquibase setup
Good for large teams and CI/CD	More complex than EF Core or DbUp
Works well with version control	Slower development cycle
Rollback & auditing support	Not .NET-native

Known Problems

🔹 Requires extra setup – Unlike EF Core or DbUp, Liquibase is not built into .NET Core and requires separate configuration.
🔹 Complex for small projects – Managing multiple formats (SQL, XML, JSON) can be overkill for simple applications.
🔹 Potential merge conflicts – Since it tracks migrations in separate files, teams working simultaneously might create conflicting changesets.

Verdict

🔹 Simplicity: ⭐⭐☆☆☆ (More setup required)
🔹 Ease of Use: ⭐⭐⭐☆☆ (Powerful, but steeper learning curve)
🔹 Speed of Development: ⭐⭐⭐☆☆ (Better for enterprise, slower for small projects)

Final Comparison Table

Tool	Simplicity	Ease of Use	Speed of Development	Known Issues
EF Core	⭐⭐⭐⭐☆	⭐⭐⭐⭐☆	⭐⭐⭐⭐☆	Model-sync issues, inefficient SQL, renaming pitfalls
DbUp	⭐⭐⭐⭐⭐	⭐⭐⭐⭐☆	⭐⭐⭐☆☆	No rollback, manual script tracking, schema drift
FluentMigrator	⭐⭐⭐☆☆	⭐⭐⭐⭐☆	⭐⭐⭐☆☆	Learning curve, ordering issues, limited tooling
Liquibase	⭐⭐☆☆☆	⭐⭐⭐☆☆	⭐⭐⭐☆☆	Setup complexity, merge conflicts, CI/CD integration overhead

Conclusion

🔹 DbUp → Ideal for SQL-first projects where developers want full control over scripts.
🔹 FluentMigrator → Great for teams wanting structured, C#-based migrations without an ORM.
🔹 EF Core → Best for ORM-driven applications that need automatic migrations.
🔹 Liquibase → Best suited for enterprise projects with complex migration needs across teams.

🚀 Choosing the right tool depends on your project’s workflow and database complexity!

---

If you don’t know what to choose, feel free to contact us!