Laravel Naming Conventions Guide

Laravel is often referred to as a magical framework, and for good reason. When you follow its default naming conventions, it feels like Laravel can read your mind. Things work without you having to write extra code or constantly configure every little detail. Instead of manually hardcoding file names, table names, or relationships, you simply follow Laravel’s naming conventions and let the framework handle the rest.

Why stick to Laravel’s naming conventions?

1. Less hassle: Laravel figures out models, tables, and relationships for you.

2. Cleaner, friendlier code: Easy to read today and months later.

3. Fewer silly bugs: No more “Oops, I named it differently in the code and the database.”

4. Faster work: Skip the boring configuration steps and get straight to building features.

5. Team harmony: Everyone instantly understands the structure without a long onboarding session.

In this blog, we will explore naming conventions for:

1. Models

2. Controllers

3. Migrations

4. CSS files

5. JavaScript files

6. Blade templates

7. Models, Tables & Relationships

1. Models

Models in Laravel represent your database tables and are stored in app/Models.

Convention:

• Singular name

• PascalCase (StudlyCase)

• No underscores or hyphens

✅ Examples:

// Good
class User extends Model {}
class OrderDetail extends Model {}

// Bad
class Users extends Model {}
class order_detail extends Model {}

📌 Why singular?
Each model represents one record in the table (one User, one Order).

---

2. Controllers

Controllers handle your application logic and live in app/Http/Controllers.

Convention:

• PascalCase

• Always end with Controller

• Group logically based on purpose

✅ Examples:

class UserController extends Controller {}
class OrderDetailController extends Controller {}

🚫 Bad:

class usercontroller {}
class Order_Detail {}

📌 Tip: Use:

php artisan make:controller UserController

to auto-follow conventions.

---

3. Migrations

Migrations define your database structure and are stored in database/migrations.

Convention:

• snake_case

• Words separated by underscores

• Describe the action + table name

• Timestamp prefix auto-generated

✅ Examples:

2025_08_15_120000_create_users_table.php
2025_08_15_120100_add_status_to_orders_table.php

📌 Tip:

php artisan make:migration create_users_table
php artisan make:migration add_status_to_orders_table --table=orders

---

4. CSS Files

Usually stored in public/css or resources/css.

Convention:

• Lowercase

• Hyphen-separated

• Descriptive names

✅ Examples:

main.css
admin-dashboard.css
user-profile.css

---

5. JavaScript Files

Stored in resources/js (for build tools) or public/js.

Convention:

• Lowercase

• Hyphen-separated

• Use action-oriented names if script is specific

✅ Examples:

app.js
form-validation.js
user-profile.js

---

6. Blade Templates

Stored in resources/views.

Convention:

• Lowercase

• Hyphen-separated

• Use folders for grouping

• No underscores

✅ Examples:

resources/views/auth/login.blade.php
resources/views/admin/dashboard.blade.php
resources/views/user/profile.blade.php

📌 Tip: Use dots in view calls:

return view('admin.dashboard');

---

7. Models, Tables & Relationships

Laravel’s Eloquent ORM has default rules for naming tables and relationships.

Models & Tables

• Models: Singular, PascalCase

• Tables: Plural, snake_case

✅ Examples:

If your table doesn’t match the convention, define it:

class UserInfo extends Model {
    protected $table = 'user_information';
}

---

Relationships

Eloquent relationships also follow specific naming:

One-to-One / One-to-Many

• Method name: singular for one-to-one, plural for one-to-many

class User extends Model {
    public function profile() {  // one-to-one
        return $this->hasOne(Profile::class);
    }

    public function posts() {    // one-to-many
        return $this->hasMany(Post::class);
    }
}

Belongs To

• Method name: singular (refers to parent)

class Post extends Model {
    public function user() {
        return $this->belongsTo(User::class);
    }
}

Many-to-Many

• Pivot table: alphabetical order, plural, snake_case

• Method name: plural

// Table: role_user (alphabetical: role before user)
class User extends Model {
    public function roles() {
        return $this->belongsToMany(Role::class);
    }
}

✅ Pivot Table Examples:

---

Primary and Foreign Key Naming Conventions in Relationships

In Laravel, following the right primary and foreign key naming patterns ensures that Eloquent relationships work without extra configuration.

• Primary Keys – Each table should have an id column as its primary key.

• One-to-Many (O2M) – The foreign key should be the singular form of the related model’s name followed by _id.

  • Example: If a Post belongs to a User, the posts table should have user_id.

• Many-to-Many (M2M) – Use a pivot table named with both related model names in singular, snake_case, arranged in alphabetical order, with each containing its foreign key in the same pattern.

  • Example: For User and Role models, pivot table → role_user

    • Columns: role_id, user_id

By sticking to these naming rules, you can define relationships without specifying custom keys, letting Laravel automatically link your models.

---

Final Thoughts

Following these conventions:

• Makes your Laravel codebase self-explanatory

• Allows Laravel’s “magic” features to work without extra configuration

• Keeps large projects clean and maintainable