How do migrations and seeders work?

Question

Accepted Answer

**Migrations** are version-controlled definitions of your database schema (creating/modifying tables) written in PHP, so schema changes are tracked with your code and reproducible across environments. **Seeders** populate the database with test or default data.

## A migration

```php
<?php
// generate: php artisan make:migration create_users_table
return new class extends Migration {
    public function up(): void {        // apply the change
        Schema::create('users', function (Blueprint $table) {
            $table->id();                          // auto-increment primary key
            $table->string('name');
            $table->string('email')->unique();
            $table->timestamps();                   // created_at + updated_at
        });
    }
    public function down(): void {       // reverse the change (rollback)
        Schema::dropIfExists('users');
    }
};
```

A migration's `up()` defines the schema change (using the `Schema` builder), and `down()` reverses it. You write the schema in PHP, not SQL — and it's database-agnostic.

## Running migrations

```bash
php artisan migrate              # apply all pending migrations
php artisan migrate:rollback     # undo the last batch (uses down())
php artisan migrate:fresh         # drop everything and re-run all (dev)
php artisan make:migration add_phone_to_users   # a new migration to alter a table
```

Migrations are **committed to version control**, so every developer, CI, and production environment reaches the same schema by running `migrate` — reproducible and team-friendly.

## Seeders — populate data

```php
class DatabaseSeeder extends Seeder {
    public function run(): void {
        User::factory()->count(50)->create();        // 50 fake users via a factory
        User::create(['name' => 'Admin', 'email' => 'admin@x.com']);
    }
}
// run with: php artisan db:seed
```

Seeders fill the database with default or test data. They pair with **factories** (generating realistic fake data) — invaluable for development and testing.

## Why it matters

Migrations and seeders are essential for working with Laravel's database layer in a professional, team-friendly way. **Migrations** solve the critical problem of keeping the database schema in sync with code: by defining schema changes as version-controlled PHP files, they make schema evolution **reproducible** (every environment — each developer's machine, CI, production — reaches the identical schema by running `migrate`), **trackable** (changes are reviewed in pull requests alongside code), and **safe** (writing schema in PHP rather than manual SQL, with reversible `down()` methods).

This eliminates schema drift and inconsistent environments — a common source of bugs. **Seeders** (with factories generating realistic fake data) populate the database for development and testing, making it easy to work with realistic data and to set up test scenarios.

Understanding the migration workflow (`make:migration`, `migrate`, `rollback`), that migrations are committed to version control for reproducibility, and how seeders/factories populate data is fundamental, everyday knowledge for any real Laravel project — it's how teams evolve their database schema collaboratively and reliably and set up data for development and tests, making it core material for professional Laravel development.