I'm currently learning Laravel, and one of the things that caught my attention was the config folder.

Coming from a backend development background, I wanted to understand what all those PHP files were doing instead of simply knowing that they "contain configuration."

When I opened a fresh Laravel project, I found files like:

config/
├── app.php
├── auth.php
├── broadcasting.php
├── cache.php
├── concurrency.php
├── cors.php
├── database.php
├── filesystems.php
├── hashing.php
├── images.php
├── logging.php
├── mail.php
├── queue.php
├── services.php
├── session.php
└── view.php

At first, it looked like a lot to understand.

So I decided to go through them one by one and document what I'm learning. Hopefully, this can also help someone else who is starting with Laravel.

Note: The exact configuration files can vary depending on your Laravel version and the packages installed in your application.

What is the config folder?

The config directory contains PHP configuration files that control different parts of your Laravel application.

You can think of it as the place where Laravel learns things like:

• How to connect to a database
• How authentication works
• How files are stored
• How emails are sent
• How caching works
• How sessions work
• How queues work
• How logging works
• How external services are configured

The structure looks roughly like:

Laravel Application
        |
        ↓
     config/
        |
   ┌────┼────┬────┬────┐
   ↓    ↓    ↓    ↓    ↓
  DB   Auth  Mail Cache Logging

1. app.php

app.php contains general configuration for your Laravel application.

For example:

return [
    'name' => env('APP_NAME', 'Laravel'),

    'env' => env('APP_ENV', 'production'),

    'debug' => (bool) env('APP_DEBUG', false),

    'url' => env('APP_URL', 'http://localhost'),

    'timezone' => 'UTC',

    'locale' => 'en',
];

It can contain settings related to:

• Application name
• Environment
• Debug mode
• Application URL
• Timezone
• Locale
• Encryption
• Service providers

For example, in .env:

APP_NAME=MyApplication

Laravel can retrieve that value using:

env('APP_NAME')

My understanding

I think of app.php as:

General settings for the Laravel application.

2. auth.php

The auth.php file deals with authentication.

Authentication is basically answering the question:

Who is this user?

This configuration can define things such as:

• Authentication guards
• User providers
• User models
• Password reset configuration

For example:

'providers' => [
    'users' => [
        'driver' => 'eloquent',
        'model' => App\Models\User::class,
    ],
],

This tells Laravel which model it should use when working with users.

For example:

User
  ↓
Login
  ↓
Authentication
  ↓
Authenticated request

My understanding

I think of auth.php as:

How Laravel identifies and authenticates users.

3. broadcasting.php

The broadcasting.php file is related to real-time events.

Broadcasting allows Laravel to send events from the server to clients in real time.

For example, imagine a chat application:

User A sends message
        ↓
Laravel
        ↓
Broadcast event
        ↓
User B receives message

This can be useful for:

• Chat applications
• Real-time notifications
• Live dashboards
• Real-time status updates

If you're building a simple CRUD API, you may not need to work with this configuration immediately.

My understanding

I think of broadcasting.php as:

Configuration for sending Laravel events to clients in real time.

4. cache.php

The cache.php file controls Laravel's caching system.

Caching allows your application to temporarily store data so that it doesn't have to perform the same expensive operation repeatedly.

For example:

Cache::put('username', 'Vincent', 3600);

Laravel can work with different cache stores depending on your configuration.

Examples include:

• File
• Database
• Redis
• Array

For example:

CACHE_STORE=redis

My understanding

I think of cache.php as:

Where and how Laravel stores cached data.

5. concurrency.php

The concurrency.php file is related to Laravel's concurrency features.

Concurrency is about allowing multiple tasks to execute without unnecessarily waiting for each one to finish before starting the next.

For example:

Without concurrency:

Task A → Task B → Task C

With concurrency:

Task A ─┐
Task B ─┼──→ Results
Task C ─┘

This can be useful when an application needs to perform several independent operations.

As I'm learning Laravel, this is one of the configuration files I'm treating as something to understand later rather than something I need to modify immediately.

My understanding

I think of concurrency.php as:

Configuration related to running multiple operations concurrently.

6. cors.php

CORS stands for Cross-Origin Resource Sharing.

This becomes especially important when you're building a separate frontend and backend.

For example:

Frontend
Next.js
http://localhost:3000

        ↓ API request

Backend
Laravel
http://localhost:8000

These are different origins.

The browser needs to know whether the frontend is allowed to communicate with the backend.

The CORS configuration deals with things such as:

• Allowed origins
• Allowed HTTP methods
• Allowed headers
• Credentials

For an API, this is particularly important.

My understanding

I think of cors.php as:

Configuration that controls which origins are allowed to communicate with my Laravel application.

7. database.php

This is one of the configuration files I'm paying the most attention to because I recently connected Laravel to PostgreSQL.

The database.php file controls Laravel's database connections.

For example, a PostgreSQL connection may look like:

'pgsql' => [
    'driver' => 'pgsql',
    'host' => env('DB_HOST', '127.0.0.1'),
    'port' => env('DB_PORT', '5432'),
    'database' => env('DB_DATABASE', 'laravel'),
    'username' => env('DB_USERNAME', 'root'),
    'password' => env('DB_PASSWORD', ''),
],

The actual values can come from .env:

DB_CONNECTION=pgsql
DB_HOST=127.0.0.1
DB_PORT=5432
DB_DATABASE=laravel
DB_USERNAME=laravel_user
DB_PASSWORD=your_password

The relationship can be understood like this:

.env
 ↓
config/database.php
 ↓
Laravel database layer
 ↓
PostgreSQL

My understanding

I think of database.php as:

How Laravel connects to and communicates with databases.

8. filesystems.php

This file controls Laravel's file storage.

Imagine an application where users can upload:

• Profile pictures
• Documents
• PDFs
• Product images
• Videos

Laravel needs to know where those files should be stored.

For example:

Storage::put('documents/example.pdf', $file);

The filesystem configuration determines which storage disk Laravel uses.

My understanding

I think of filesystems.php as:

Where and how Laravel stores files.

9. hashing.php

The hashing.php file controls Laravel's hashing configuration.

Hashing is particularly important when dealing with passwords.

You should never store passwords as plain text:

password123

Instead, the password is hashed before being stored:

password123
      ↓
    Hash
      ↓
   Database

Laravel supports hashing algorithms such as:

• Bcrypt
• Argon
• Argon2id

My understanding

I think of hashing.php as:

How Laravel hashes sensitive data such as passwords.

10. images.php

The images.php configuration file is related to image handling and processing.

This can become useful when an application needs to work with uploaded images.

For example:

• Resizing images
• Processing images
• Optimizing images
• Converting images

This might be useful in applications such as e-commerce platforms where users upload product images.

My understanding

I think of images.php as:

Configuration related to image processing.

11. logging.php

The logging.php file controls Laravel's logging system.

Logs are extremely useful when debugging an application.

Laravel can write logs to files such as:

storage/logs/laravel.log

You can also create your own logs:

Log::info('User registered successfully');

Or:

Log::error('Payment failed');

Laravel supports different logging channels.

My understanding

I think of logging.php as:

How Laravel records application events, warnings, and errors.

When debugging Laravel applications, I'll probably spend quite a lot of time looking at:

storage/logs/laravel.log

12. mail.php

The mail.php file controls email configuration.

Laravel applications commonly need to send emails for things such as:

• Password resets
• Email verification
• Booking confirmations
• Payment receipts
• Notifications

For example, .env might contain:

MAIL_MAILER=smtp
MAIL_HOST=smtp.example.com
MAIL_PORT=587
MAIL_USERNAME=your_username
MAIL_PASSWORD=your_password

Laravel uses the mail configuration to determine how emails should be sent.

My understanding

I think of mail.php as:

How Laravel sends emails.

13. queue.php

The queue.php file controls Laravel's queue system.

Queues are useful for tasks that don't need to happen before the user receives a response.

For example, sending an email could be handled in the background:

User registers
      ↓
Laravel creates account
      ↓
Email job added to queue
      ↓
Response returned
      ↓
Queue worker sends email

Instead of:

User registers
      ↓
Create account
      ↓
Send email
      ↓
Wait...
      ↓
Return response

Queues can improve application responsiveness.

My understanding

I think of queue.php as:

How Laravel handles background jobs.

14. services.php

The services.php file is commonly used for third-party services.

For example:

• GitHub
• Google
• Stripe
• PayPal
• AWS
• External APIs

You might have configuration like:

'github' => [
    'client_id' => env('GITHUB_CLIENT_ID'),
    'client_secret' => env('GITHUB_CLIENT_SECRET'),
    'redirect' => env('GITHUB_REDIRECT_URI'),
],

The actual credentials would normally be stored in .env:

GITHUB_CLIENT_ID=your_client_id
GITHUB_CLIENT_SECRET=your_client_secret
GITHUB_REDIRECT_URI=http://localhost:8000/auth/github/callback

My understanding

I think of services.php as:

Configuration for services outside the Laravel application.

15. session.php

The session.php file controls Laravel's session management.

Sessions allow an application to remember information between HTTP requests.

For example:

User logs in
     ↓
Session created
     ↓
User visits another page
     ↓
Laravel knows the user

Laravel can store sessions using different drivers.

For example:

SESSION_DRIVER=file

or:

SESSION_DRIVER=database

My understanding

I think of session.php as:

How Laravel stores and manages user sessions.

16. view.php

The view.php file contains configuration related to Laravel's views.

Laravel's traditional server-side frontend system uses Blade templates.

For example:

resources/
└── views/
    ├── welcome.blade.php
    └── dashboard.blade.php

The view configuration helps Laravel locate and work with these templates.

If you're building a Laravel API without Blade, you may not interact with this file very often.

My understanding

I think of view.php as:

Configuration for Laravel's view system.

Which Configuration Files Should I Learn First?

As someone learning Laravel from a backend development perspective, I'm not trying to memorize everything at once.

I'd prioritize them like this:

Learn first

app.php
auth.php
database.php
hashing.php
logging.php
services.php

Then:

cache.php
cors.php
queue.php
session.php

And later:

broadcasting.php
concurrency.php
filesystems.php
images.php
mail.php
view.php

This doesn't mean the second group is less important. It just means you don't need to understand every Laravel feature on day one.

.env vs config

This was one of the most important things for me to understand.

Laravel has a .env file:

.env

and a configuration directory:

config/

They work together, but they have different purposes.

For example, .env might contain:

DB_CONNECTION=pgsql
DB_HOST=127.0.0.1
DB_PORT=5432
DB_DATABASE=laravel
DB_USERNAME=laravel_user
DB_PASSWORD=your_password

Then config/database.php reads those values:

'pgsql' => [
    'driver' => 'pgsql',
    'host' => env('DB_HOST', '127.0.0.1'),
    'port' => env('DB_PORT', '5432'),
    'database' => env('DB_DATABASE', 'laravel'),
    'username' => env('DB_USERNAME', 'root'),
    'password' => env('DB_PASSWORD', ''),
],

So I think of it like this:

.env
  ↓
Environment-specific values
  ↓
config/*.php
  ↓
Laravel configuration
  ↓
Laravel application

env() vs config()

You'll see these two functions frequently when working with Laravel.

env()

env() reads environment variables.

For example:

APP_NAME=MyApplication

You can access it with:

env('APP_NAME')

config()

config() reads Laravel's configuration.

For example:

config('app.name')

This can retrieve the application name configured in config/app.php.

A useful rule I'm learning is:

Use env() mainly inside configuration files, and use config() in application code.

For example, in application code, prefer:

config('app.timezone')

rather than repeatedly accessing:

env('APP_TIMEZONE')

Why php artisan config:clear Is Important

While setting up PostgreSQL, I ran into a situation where Laravel wasn't using the database configuration I expected.

One command I learned about was:

php artisan config:clear

This clears Laravel's cached configuration.

Laravel can cache configuration to improve performance, especially in production.

If you change your .env file and Laravel appears to be ignoring your changes, you can try:

php artisan config:clear

Then test your application again.

You can also rebuild the configuration cache with:

php artisan config:cache

A Simple Way to Remember the Files

Here's how I'm currently thinking about the configuration files:

Coming From Django?

Since I also work with Django, comparing Laravel with Django helps me understand the concepts.

The two frameworks aren't identical, but there are some useful similarities:

Coming from Django, this comparison makes Laravel's structure a little easier for me to understand.

Final Thoughts

I'm learning that I don't need to understand every Laravel configuration file immediately.

The important thing is to understand why the files exist and when I might need them.

For backend development, the configuration files I'll probably interact with most often are:

database.php
auth.php
app.php
cors.php
logging.php
queue.php
cache.php
services.php

The more I build applications with Laravel, the more these configurations will start making sense through practical use.

I'm sharing this as part of my Laravel learning journey. If you're also learning Laravel, hopefully this gives you a simple starting point for understanding what's inside the config directory.

And if I've misunderstood anything, feel free to correct me in the comments. That's part of learning.