When building a Laravel application, managing the database is just as important as writing application code. As your application grows, you need a reliable way to create database tables, modify existing columns, add indexes, and populate databases with test or initial data.

This is where Laravel migrations and seeders become essential.

Laravel migrations allow developers to manage database structure using version-controlled PHP files, while seeders make it easy to insert predefined or sample data into the database.

In this guide, you’ll learn Laravel migrations and seeders with practical examples, including how to create migrations, modify database tables, roll back changes, create seeders, use model factories, run migrations and seeders, and follow database management best practices.

---

What Are Laravel Migrations?

A Laravel migration is a PHP file that describes a change to your application’s database structure.

Instead of manually creating database tables using SQL, Laravel allows you to define database structures using PHP and Laravel’s Schema Builder.

For example:

Schema::create('products', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->decimal('price', 10, 2);
    $table->timestamps();
});

This migration can create a products table with:

• An auto-incrementing ID
• Product name
• Product price
• created_at timestamp
• updated_at timestamp

The biggest advantage is that database changes can be stored in your source code and shared with other developers.

---

Why Are Laravel Migrations Important?

Without migrations, developers often need to manually create or modify database tables.

That becomes difficult when working with:

• Multiple developers
• Development environments
• Staging servers
• Production servers
• CI/CD pipelines
• Multiple databases

Laravel migrations solve this by making database changes reproducible.

For example:

Developer A
     │
     ▼
Migration File
     │
     ▼
Git Repository
     │
     ├───────────────┐
     ▼               ▼
Developer B       Production
     │               │
     ▼               ▼
Same Database Structure

Everyone can run the same migration files and create the expected database structure.

---

Where Are Laravel Migrations Stored?

Laravel migrations are stored in:

database/migrations

A typical Laravel project may contain:

database/
├── factories/
├── migrations/
│   ├── 2026_01_01_000001_create_users_table.php
│   ├── 2026_01_01_000002_create_products_table.php
│   └── 2026_01_01_000003_create_orders_table.php
└── seeders/

Migration filenames contain timestamps.

Laravel uses these timestamps to determine the order in which migrations should run.

---

How to Create a Laravel Migration

You can create a migration using Artisan:

php artisan make:migration create_products_table

Laravel generates a migration file inside:

database/migrations

For a new table, you can also use:

php artisan make:migration create_products_table --create=products

The generated file will contain methods similar to:

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up(): void
    {
        //
    }

    public function down(): void
    {
        //
    }
};

---

Understanding the up() and down() Methods

Every Laravel migration generally contains two important methods.

The up() Method

The up() method defines what should happen when the migration is executed.

For example:

public function up(): void
{
    Schema::create('products', function (Blueprint $table) {
        $table->id();
        $table->string('name');
        $table->decimal('price', 10, 2);
        $table->timestamps();
    });
}

This creates the products table.

The down() Method

The down() method defines how the migration can be reversed.

public function down(): void
{
    Schema::dropIfExists('products');
}

The relationship is:

php artisan migrate
        │
        ▼
      up()
        │
        ▼
Database Changes


php artisan rollback
        │
        ▼
      down()
        │
        ▼
Reverse Database Changes

---

Creating a Database Table With Laravel Migrations

Let’s create a products table.

Schema::create('products', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->text('description')->nullable();
    $table->decimal('price', 10, 2);
    $table->boolean('is_active')->default(true);
    $table->timestamps();
});

This creates a structure similar to:

Column	Type	Purpose
id	BIGINT	Primary key
name	VARCHAR	Product name
description	TEXT	Product description
price	DECIMAL	Product price
is_active	BOOLEAN	Product status
created_at	TIMESTAMP	Creation time
updated_at	TIMESTAMP	Last update time

---

Common Laravel Migration Column Types

Laravel’s Schema Builder supports many common column types.

Some frequently used types include:

$table->id();
$table->string('name');
$table->text('description');
$table->integer('quantity');
$table->decimal('price', 10, 2);
$table->boolean('is_active');
$table->date('published_at');
$table->dateTime('scheduled_at');
$table->json('metadata');
$table->uuid('uuid');
$table->timestamps();

Choosing the correct database type is important because it affects storage, validation, queries, and application behavior.

---

Nullable Columns

Sometimes a database field should be optional.

Use nullable():

$table->string('phone')->nullable();

This allows the column to contain NULL.

For example:

$table->text('description')->nullable();

is useful when a product description isn’t mandatory.

---

Default Values

You can specify a default value:

$table->boolean('is_active')->default(true);

Another example:

$table->integer('quantity')->default(0);

This means a value is automatically assigned when the application doesn’t provide one.

---

Unique Columns

If a field must contain unique values, use:

$table->string('email')->unique();

This is commonly used for:

• Email addresses
• Usernames
• Product SKUs
• Order numbers
• Unique identifiers

For example:

Schema::create('users', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->string('email')->unique();
    $table->timestamps();
});

---

Laravel Foreign Keys

Migrations can also define relationships between tables.

Suppose each product belongs to a category.

You might have:

Schema::create('products', function (Blueprint $table) {
    $table->id();
    $table->foreignId('category_id')
        ->constrained()
        ->cascadeOnDelete();

    $table->string('name');
    $table->decimal('price', 10, 2);
    $table->timestamps();
});

This creates a foreign key relationship between products.category_id and the referenced category table.

A simplified relationship looks like:

categories
    │
    │ 1
    │
    ▼
products
    │
    │ many

Foreign keys help maintain referential integrity within the database.

---

Running Laravel Migrations

Once your migration is ready, run:

php artisan migrate

Laravel checks which migrations have not yet been executed and runs them.

You can think of the process like this:

Migration Files
      │
      ▼
Laravel Migration System
      │
      ▼
Database
      │
      ▼
Tables / Columns / Indexes

---

Checking Migration Status

To see which migrations have already run:

php artisan migrate:status

You may see output showing migrations as completed or pending.

This is particularly useful when debugging database changes.

---

Rolling Back Laravel Migrations

If you need to reverse the latest migration batch, use:

php artisan migrate:rollback

For example:

Migration
    │
    ▼
create_products_table
    │
    ▼
products table created


Rollback
    │
    ▼
products table removed

The rollback uses the migration’s down() method.

---

Refreshing Migrations

Laravel provides:

php artisan migrate:refresh

This rolls back migrations and runs them again.

It can be useful during local development when you want to rebuild the database structure.

---

Fresh Migrations

Another useful command is:

php artisan migrate:fresh

This drops all tables and runs all migrations again.

You can combine it with seeders:

php artisan migrate:fresh --seed

This is particularly useful for rebuilding a local development database.

Important: Do not casually run migrate:fresh against a production database because it drops all tables.

---

Modifying Existing Tables

Migrations aren’t only for creating new tables. They can also modify existing tables.

For example, suppose you already have a products table and want to add a SKU column.

Create a migration:

php artisan make:migration add_sku_to_products_table

Then:

Schema::table('products', function (Blueprint $table) {
    $table->string('sku')->unique()->after('name');
});

The down() method should reverse the change:

public function down(): void
{
    Schema::table('products', function (Blueprint $table) {
        $table->dropUnique(['sku']);
        $table->dropColumn('sku');
    });
}

This approach is preferable to modifying an old migration that has already been deployed.

---

Renaming Columns

Laravel migrations can also rename columns.

For example:

Schema::table('products', function (Blueprint $table) {
    $table->renameColumn('name', 'product_name');
});

When changing database structures, always consider existing application code and production data before making destructive changes.

---

Dropping Columns

To remove a column:

Schema::table('products', function (Blueprint $table) {
    $table->dropColumn('description');
});

For production applications, dropping columns should be planned carefully because existing data will be permanently removed.

---

What Are Laravel Seeders?

While migrations define the database structure, Laravel seeders are used to populate the database with data.

For example, you might want to create:

• Admin users
• Categories
• Default application settings
• Test products
• Demo accounts
• Sample orders

Instead of manually inserting this data every time, you can create a seeder.

---

How to Create a Laravel Seeder

Use Artisan:

php artisan make:seeder ProductSeeder

Laravel creates:

database/seeders/ProductSeeder.php

A basic seeder looks like:

namespace Database\Seeders;

use Illuminate\Database\Seeder;

class ProductSeeder extends Seeder
{
    public function run(): void
    {
        //
    }
}

You can then insert data inside the run() method.

---

Inserting Data With a Seeder

For example:

use App\Models\Product;

public function run(): void
{
    Product::create([
        'name' => 'Laptop',
        'price' => 799.99,
        'is_active' => true,
    ]);
}

You can insert multiple products:

public function run(): void
{
    Product::create([
        'name' => 'Laptop',
        'price' => 799.99,
        'is_active' => true,
    ]);

    Product::create([
        'name' => 'Keyboard',
        'price' => 49.99,
        'is_active' => true,
    ]);

    Product::create([
        'name' => 'Mouse',
        'price' => 29.99,
        'is_active' => true,
    ]);
}

For larger datasets, factories are usually a better approach.

---

Laravel Model Factories and Seeders

Laravel factories allow you to generate realistic test data.

For example:

php artisan make:factory ProductFactory

A factory might contain:

public function definition(): array
{
    return [
        'name' => fake()->words(3, true),
        'price' => fake()->randomFloat(2, 10, 1000),
        'is_active' => true,
    ];
}

You can then create records using the factory:

Product::factory()->count(50)->create();

This is much more convenient than manually writing 50 records.

---

Seeders vs Factories

Although seeders and factories are related, they have different responsibilities.

Feature	Migrations	Seeders	Factories
Database structure	Yes	No	No
Insert data	No	Yes	Yes
Generate fake data	No	Sometimes	Yes
Create tables	Yes	No	No
Version controlled	Yes	Yes	Yes
Useful for test data	Indirectly	Yes	Excellent
Production defaults	No	Yes	Sometimes

A simple way to remember them:

Migration
   ↓
"What should the database structure look like?"

Seeder
   ↓
"What initial data should exist?"

Factory
   ↓
"How can I generate realistic sample data?"

---

Running Laravel Seeders

To run the default database seeder:

php artisan db:seed

To run a specific seeder:

php artisan db:seed --class=ProductSeeder

You can also run migrations and seed the database together:

php artisan migrate --seed

For a complete local database reset:

php artisan migrate:fresh --seed

---

Using DatabaseSeeder

Laravel provides a central seeder:

database/seeders/DatabaseSeeder.php

You can call other seeders from it:

namespace Database\Seeders;

use Illuminate\Database\Seeder;

class DatabaseSeeder extends Seeder
{
    public function run(): void
    {
        $this->call([
            ProductSeeder::class,
            CategorySeeder::class,
        ]);
    }
}

Now running:

php artisan db:seed

will execute the specified seeders.

---

Complete Migration and Seeder Example

Let’s build a simple category and product example.

Step 1: Create the Category Migration

php artisan make:migration create_categories_table

Migration:

Schema::create('categories', function (Blueprint $table) {
    $table->id();
    $table->string('name')->unique();
    $table->timestamps();
});

---

Step 2: Create the Product Migration

php artisan make:migration create_products_table

Migration:

Schema::create('products', function (Blueprint $table) {
    $table->id();

    $table->foreignId('category_id')
        ->constrained()
        ->cascadeOnDelete();

    $table->string('name');
    $table->decimal('price', 10, 2);
    $table->boolean('is_active')->default(true);

    $table->timestamps();
});

---

Step 3: Create Category Seeder

php artisan make:seeder CategorySeeder

Then:

use App\Models\Category;

public function run(): void
{
    Category::create([
        'name' => 'Electronics',
    ]);

    Category::create([
        'name' => 'Accessories',
    ]);
}

---

Step 4: Create Product Seeder

php artisan make:seeder ProductSeeder

Then:

use App\Models\Category;
use App\Models\Product;

public function run(): void
{
    $electronics = Category::where(
        'name',
        'Electronics'
    )->first();

    Product::create([
        'category_id' => $electronics->id,
        'name' => 'Laptop',
        'price' => 799.99,
        'is_active' => true,
    ]);
}

---

Step 5: Register the Seeders

Inside DatabaseSeeder.php:

public function run(): void
{
    $this->call([
        CategorySeeder::class,
        ProductSeeder::class,
    ]);
}

---

Step 6: Run Everything

php artisan migrate --seed

The resulting flow is:

Migrations
    │
    ▼
Create Categories
    │
    ▼
Create Products
    │
    ▼
Seed Categories
    │
    ▼
Seed Products
    │
    ▼
Ready Database

---

Laravel Migrations and Seeders in Development

Migrations and seeders are particularly useful when working in a development team.

Imagine a team has:

Developer A
Developer B
Developer C

Instead of sending SQL instructions manually, a developer can commit:

Migration
Seeder
Factory
Model

to Git.

Other developers can then run:

php artisan migrate

and:

php artisan db:seed

This creates a consistent development environment.

---

Laravel Migrations in Production

Migrations are also commonly used when deploying Laravel applications.

A typical deployment may include:

php artisan migrate --force

The --force option allows migrations to run in production without an interactive confirmation prompt.

Production migrations should always be reviewed carefully before deployment.

Avoid destructive database changes without a proper migration and deployment strategy.

---

Common Laravel Migration and Seeder Mistakes

1. Editing Old Migrations After Deployment

Once a migration has already been shared or deployed, avoid changing it to represent a new database modification.

Instead, create a new migration:

php artisan make:migration add_status_to_orders_table

This preserves the history of database changes.

---

2. Running migrate:fresh on Production

This command:

php artisan migrate:fresh

drops all tables before running migrations again.

That means existing data can be destroyed.

Use it primarily for local development and controlled environments.

---

3. Forgetting Foreign Key Order

If one table references another, migrations must create the referenced table first.

For example:

categories
     │
     ▼
products

The categories migration should run before the products migration.

Laravel migration timestamps normally help control execution order.

---

4. Creating Seeders That Depend on Unstable IDs

Avoid relying on hardcoded database IDs such as:

'category_id' => 1

when the ID isn’t guaranteed to be stable.

Instead, look up the related record:

$category = Category::where('name', 'Electronics')->first();

Then use:

'category_id' => $category->id

---

5. Running Large Seeders Inefficiently

Creating thousands of records individually can be slow.

Factories and bulk inserts can be more efficient for large datasets.

For example:

Product::factory()
    ->count(1000)
    ->create();

---

Laravel Migration and Seeder Best Practices

1. Keep Migrations Focused

A migration should ideally represent a clear database change.

For example:

create_users_table
add_status_to_orders_table
add_sku_to_products_table

Clear migration names make database history easier to understand.

2. Never Store Secrets in Seeders

Avoid putting passwords, API keys, or production credentials directly inside seeders.

Use environment variables and proper application configuration.

3. Use Factories for Test Data

Factories are ideal for generating large amounts of realistic development and testing data.

4. Make Seeders Reproducible

A good seeder should produce predictable results when run in the intended environment.

5. Review Production Migrations

Before deploying migrations, consider:

• Existing data
• Table size
• Index changes
• Foreign keys
• Downtime
• Backward compatibility
• Rollback strategy

6. Keep Database Changes in Version Control

Commit migrations, seeders, and factories to Git so your team can reproduce the database environment.

---

Migration Workflow vs Seeder Workflow

A typical Laravel database workflow looks like this:

             DATABASE DEVELOPMENT
                     │
          ┌──────────┴──────────┐
          ▼                     ▼
     Migrations              Seeders
          │                     │
          ▼                     ▼
 Database Structure        Initial Data
          │                     │
          └──────────┬──────────┘
                     ▼
                  Models
                     │
                     ▼
               Laravel App

Factories complement this workflow by generating test and development data.

---

Laravel Migrations vs Raw SQL

Laravel migrations are not the only way to modify a database. Developers can also execute raw SQL.

However, migrations provide several advantages:

Feature	Laravel Migration	Manual SQL
Version control	Excellent	Manual
Laravel integration	Excellent	Limited
Team collaboration	Easy	More difficult
Rollbacks	Supported	Manual
Database schema readability	High	Depends on SQL
Framework tooling	Extensive	Limited
Automation	Excellent	Requires setup

For most Laravel applications, migrations are the preferred way to manage schema changes.

---

Quick Laravel Migration and Seeder Command Reference

# Create a migration
php artisan make:migration create_products_table

# Create a migration for a new table
php artisan make:migration create_products_table --create=products

# Run migrations
php artisan migrate

# Check migration status
php artisan migrate:status

# Roll back the latest batch
php artisan migrate:rollback

# Refresh migrations
php artisan migrate:refresh

# Drop all tables and run migrations
php artisan migrate:fresh

# Create a seeder
php artisan make:seeder ProductSeeder

# Run seeders
php artisan db:seed

# Run a specific seeder
php artisan db:seed --class=ProductSeeder

# Run migrations and seed
php artisan migrate --seed

# Rebuild database and seed
php artisan migrate:fresh --seed

---

Frequently Asked Questions

What are Laravel migrations?

Laravel migrations are version-controlled PHP files used to create and modify database structures. They allow developers to define tables, columns, indexes, foreign keys, and other schema changes using Laravel’s Schema Builder.

What are Laravel seeders?

Laravel seeders are PHP classes used to insert predefined or sample data into a database. They are useful for creating default records, demo data, development data, and initial application configuration.

What is the difference between Laravel migrations and seeders?

Migrations define the database structure, while seeders populate the database with data.

In simple terms:

Migration = Database structure
Seeder    = Database data

How do I run Laravel migrations and seeders together?

Use:

php artisan migrate --seed

This runs pending migrations and then executes the database seeder.

For a complete local database rebuild, you can use:

php artisan migrate:fresh --seed

What is the difference between seeders and factories in Laravel?

Seeders define what data should be inserted, while factories define how model data can be generated.

Factories are especially useful for creating large amounts of realistic test data.

Can Laravel migrations be rolled back?

Yes. Laravel migrations generally include a down() method that reverses the changes made by up().

Use:

php artisan migrate:rollback

to roll back the latest migration batch.

Should I edit an existing Laravel migration?

If a migration has already been deployed or shared with other developers, it is generally better to create a new migration for the new change rather than modifying the old migration.

Is migrate:fresh safe for production?

No. migrate:fresh drops all database tables before running migrations again. It can permanently remove existing data and should generally be reserved for local development or carefully controlled environments.

---

Key Takeaways

Laravel migrations and seeders make database management more structured and repeatable.

Remember:

• Migrations define database structure.
• Seeders populate database data.
• Factories generate realistic test data.
• Use php artisan migrate to run migrations.
• Use php artisan db:seed to run seeders.
• Use php artisan migrate --seed to run both.
• Use foreign keys to maintain relationships between tables.
• Create new migrations for changes to already-deployed schemas.
• Avoid destructive commands such as migrate:fresh on production databases.
• Use version control for migrations, seeders, and factories.

---

Conclusion

Laravel migrations and seeders are essential tools for building and maintaining modern Laravel applications.

Migrations provide a reliable way to define and evolve your database schema, while seeders make it easy to populate databases with default, sample, or development data. When combined with Laravel model factories, they provide a powerful workflow for creating consistent development and testing environments.

A well-structured Laravel project should treat database changes as part of the application’s source code. Instead of manually changing databases, create migrations, commit them to version control, and allow every environment to reproduce the required database structure.

Once you understand how migrations, seeders, and factories work together, managing Laravel databases becomes significantly easier, more predictable, and more scalable.

---