See ALL available commands

php artisan list

Get detailed help for any command

php artisan help migrate

Generate multiple files at once

php artisan make:model Post -mcr

This creates: Model, Migration, Controller, and Resource in one go!

Clear everything at once during development

php artisan optimize:clear

Pro tip: Create an alias in your shell for `php artisan` - I use `pa` and it saves me probably 30 seconds every hour. That adds up!

![image_1](https://cdn.marblism.com/jHmqkZ1psMC.webp)

## 2. Route Caching Will Save Your Sanity

If your app has more than 50 routes, you NEED to implement route caching. I learned this the hard way when my dashboard was taking 3+ seconds to load.

```bash
# Cache your routes for production
php artisan route:cache

# Clear when you add new routes
php artisan route:clear

But here's the catch - route caching only works if ALL your routes use controller actions instead of closures. So instead of this:

// DON'T do this if you want caching
Route::get('/dashboard', function () {
    return view('dashboard');
});

Do this:

// DO this instead
Route::get('/dashboard', [DashboardController::class, 'index']);

The performance boost? In my experience, anywhere from 30-70% faster route resolution.

3. Stop the N+1 Query Nightmare with Eager Loading

OOPS! Let me guess - your app is making 100+ database queries on a single page? Been there, done that, got the slow website to prove it.

Here's the classic N+1 problem:

// This will make 1 + N queries (BAD!)
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->user->name; // Each iteration hits the database
}

The fix is embarrassingly simple:

// This makes only 2 queries (GOOD!)
$posts = Post::with('user')->get();
foreach ($posts as $post) {
    echo $post->user->name; // No additional queries
}

Want to get fancy? Use nested eager loading:

$posts = Post::with(['user', 'comments.author'])->get();

4. Queues Are Your Best Friend for Background Tasks

Stop making your users wait for emails to send or images to process! Seriously, there's no excuse for this anymore.

First, set up your queue driver (Redis is my go-to):

// In your .env
QUEUE_CONNECTION=redis

Then create a job:

php artisan make:job SendWelcomeEmail

class SendWelcomeEmail implements ShouldQueue
{
    public function __construct(
        public User $user
    ) {}

    public function handle()
    {
        Mail::to($this->user)->send(new WelcomeMail($this->user));
    }
}

Dispatch it like this:

// Instead of sending immediately
Mail::to($user)->send(new WelcomeMail($user));

// Queue it for background processing
SendWelcomeEmail::dispatch($user);

5. View Caching is Low-Hanging Fruit

This one's almost too easy. Laravel compiles your Blade templates every time they change, but you can cache the compiled versions:

# Cache compiled views
php artisan view:cache

# Clear when deploying new code
php artisan view:clear

For an extra boost, cache your config too:

php artisan config:cache

Just remember to clear these in development when you make changes!

6. Query Scopes Keep Your Code DRY

Instead of repeating complex queries throughout your app, use local scopes. They're like reusable query snippets.

// In your User model
public function scopeActive($query)
{
    return $query->where('status', 'active');
}

public function scopeAdmins($query)
{
    return $query->where('role', 'admin');
}

// Now use them anywhere
$activeUsers = User::active()->get();
$adminUsers = User::active()->admins()->get();

You can even pass parameters:

public function scopeCreatedAfter($query, $date)
{
    return $query->where('created_at', '>=', $date);
}

// Usage
$recentUsers = User::createdAfter(now()->subDays(7))->get();

7. Service Classes Will Save Your Controllers

Fat controllers are the enemy of maintainable code. When your controller methods are 50+ lines, it's time to extract that logic.

Instead of this monster:

class OrderController extends Controller
{
    public function store(Request $request)
    {
        // 50 lines of validation, calculation, email sending, etc.
    }
}

Do this:

class OrderController extends Controller
{
    public function store(Request $request, OrderService $orderService)
    {
        $order = $orderService->createOrder($request->validated());
        
        return redirect()->route('orders.show', $order);
    }
}

class OrderService
{
    public function createOrder(array $data): Order
    {
        // All your business logic lives here
        // Easy to test, reuse, and maintain
    }
}

8. Custom Artisan Commands Are Game Changers

Stop doing repetitive tasks manually! Create custom commands for anything you do more than twice.

php artisan make:command CleanupOldLogs

class CleanupOldLogs extends Command
{
    protected $signature = 'logs:cleanup {--days=30}';
    protected $description = 'Clean up old log files';

    public function handle()
    {
        $days = $this->option('days');
        
        // Your cleanup logic here
        
        $this->info("Cleaned up logs older than {$days} days!");
    }
}

Now you can run:

php artisan logs:cleanup
php artisan logs:cleanup --days=7

Schedule it to run automatically:

// In app/Console/Kernel.php
protected function schedule(Schedule $schedule)
{
    $schedule->command('logs:cleanup')->daily();
}

9. Laravel Collections Are Pure Magic

Collections make working with arrays feel like poetry. Seriously, once you start chaining collection methods, you'll never go back.

Instead of this PHP mess:

$users = User::all();
$activeAdminEmails = [];

foreach ($users as $user) {
    if ($user->status === 'active' && $user->role === 'admin') {
        $activeAdminEmails[] = $user->email;
    }
}

Write this elegant Laravel code:

$activeAdminEmails = User::all()
    ->where('status', 'active')
    ->where('role', 'admin')
    ->pluck('email');

Collections have tons of useful methods:

$collection = collect([1, 2, 3, 4, 5]);

$result = $collection
    ->filter(fn($item) => $item > 2)
    ->map(fn($item) => $item * 2)
    ->sum();
// Result: 24 (6 + 8 + 10)

10. Laravel Telescope is Your Debugging Superpower

OOPS! Spending hours debugging performance issues? Telescope shows you exactly what's happening under the hood.

Install it (development only!):

composer require laravel/telescope --dev
php artisan telescope:install
php artisan migrate