⚙️ Setting Up a Laravel Application

Introduction & Prerequisites

Setting up a Laravel app is like prepping a kitchen before an elaborate meal — the time you invest up front pays dividends every time you cook. Whether you are building a blog or an enterprise platform, the setup follows the same repeatable pattern.

Before installing Laravel 11, make sure your machine has:

• PHP 8.2 or higher — Laravel 11 requires it (8.3 is recommended).
• Composer — PHP's dependency manager, used to pull in Laravel and its packages.
• A database — MySQL, PostgreSQL, SQLite, or SQL Server. SQLite needs zero setup, so it is perfect for learning.
• Node.js & npm — for compiling front-end assets with Vite.
• Required PHP extensions — Ctype, cURL, DOM, Fileinfo, Filter, Hash, Mbstring, OpenSSL, PCRE, PDO, Session, Tokenizer, and XML (all standard in a normal PHP build).

Three Ways to Install

There is more than one road to a new project. Pick the one that matches how often you start Laravel apps and whether you want Docker.

Method 1 — Composer create-project

The most direct route. This works anywhere Composer runs and needs nothing installed globally.

composer create-project laravel/laravel example-app
cd example-app
php artisan serve

Think of it as buying a flat-pack furniture kit: every standard piece arrives in the expected place.

Method 2 — The Laravel installer

If you spin up Laravel projects often, install the global installer once and use the shorter laravel new command. Modern versions can even scaffold a starter kit, testing framework, and database interactively.

# Install the installer globally (one time)
composer global require laravel/installer

# Create a new project
laravel new example-app

Like a template cutter in a workshop — precise and consistent every time.

Method 3 — Docker with Laravel Sail

Sail gives you a full Docker environment (PHP, MySQL, Redis, and more) with zero local PHP required. Ideal for keeping every teammate's setup identical.

# Scaffold a new app with a Docker environment
curl -s "https://laravel.build/example-app" | bash

cd example-app

# Bring the containers up
./vendor/bin/sail up

Sail is the pre-calibrated workshop: every tool is already set up so you can focus on building, not configuring.

The Directory Structure

A fresh install is well organized. Knowing the floor plan lets you navigate without hunting. Laravel 11's skeleton is deliberately slimmer than older versions — fewer files, clearer defaults.

Environment & the .env File

Laravel keeps environment-specific settings — database credentials, API keys, debug flags — in a .env file at the project root. The same codebase can then run in local, staging, and production simply by swapping this file. Config files in config/ read these values via the env() helper.

# .env (excerpt)
APP_NAME=Laravel
APP_ENV=local
APP_KEY=base64:GENERATED_KEY_HERE
APP_DEBUG=true
APP_URL=http://localhost

# SQLite — the easiest database to start with
DB_CONNECTION=sqlite

# Or MySQL:
# DB_CONNECTION=mysql
# DB_HOST=127.0.0.1
# DB_PORT=3306
# DB_DATABASE=example_app
# DB_USERNAME=root
# DB_PASSWORD=secret

The application key

Every Laravel app needs an APP_KEY — a random 32-byte string used to encrypt sessions and cookies. The installers generate it for you, but if you clone a project (which won't include the git-ignored .env), generate one:

php artisan key:generate

Without this key, encrypted data cannot be secured — treat it like the master key to your building.

💡 Analogy: The .env file is a theatre's lighting board. The play (your code) is identical from venue to venue; only the board's settings change to suit each stage.

Database & Migrations

Once your connection is set in .env, you define your schema with migrations — versioned PHP files that describe tables. Migrations live in your repository, so your database structure travels with your code and every teammate gets the same schema.

If you chose SQLite, create the empty database file first, then migrate:

# SQLite only: create the database file
touch database/database.sqlite

# Create a migration
php artisan make:migration create_products_table

# Apply all pending migrations
php artisan migrate

# Roll back the most recent batch
php artisan migrate:rollback

# Wipe and re-run everything (great while developing)
php artisan migrate:fresh

A migration has two halves: up() builds the change, down() reverses it.

<?php

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

return new class extends Migration
{
    public function up(): void
    {
        Schema::create('products', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->text('description')->nullable();
            $table->integer('price_cents');
            $table->timestamps();
        });
    }

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

The Artisan CLI

Artisan is Laravel's command-line assistant. It scaffolds files, runs migrations, clears caches, and hosts your dev server — the Swiss Army knife you will reach for constantly.

# See every available command
php artisan list

# Help for one command
php artisan help migrate

# Scaffold common pieces
php artisan make:controller ProductController
php artisan make:model Product -m      # model + its migration
php artisan make:migration create_orders_table

# Maintenance
php artisan config:clear
php artisan route:list                  # show every registered route

The make:* commands are the most-used: they generate correctly-named, correctly-placed files so you never start from a blank page. Using Artisan is like having a skilled assistant handle the boilerplate while you focus on the logic.

Running & Building

The development server

Laravel ships with a built-in PHP server, so you can start coding without configuring Apache or Nginx:

# Serve at http://127.0.0.1:8000
php artisan serve

# Custom host and port
php artisan serve --host=0.0.0.0 --port=8080

This server is for development only — think prototype workbench, not the production factory. In production you front the app with Nginx or Apache (or a managed platform).

Front-end assets with Vite

Laravel 11 uses Vite to compile the CSS and JavaScript in resources/. Install the Node dependencies once, then run the dev server for instant hot-reloading while you work:

# Install front-end dependencies (one time)
npm install

# Dev server with hot module replacement
npm run dev

# Optimized production build → public/build
npm run build

Run php artisan serve and npm run dev in two terminals side by side during development: one serves your PHP, the other rebuilds assets the moment you save.

Hands-on Exercise

composer create-project laravel/laravel demo-app
cd demo-app

# In .env set: DB_CONNECTION=sqlite  (delete the DB_HOST/PORT/DATABASE/USERNAME/PASSWORD lines)

touch database/database.sqlite
php artisan migrate          # builds users, cache, jobs tables
php artisan serve            # http://127.0.0.1:8000

php artisan route:list       # the "/" GET route renders welcome.blade.php

Summary & Quiz

📚 Further Reading

• Laravel Docs — Installation
• Laravel Docs — Directory Structure
• Laravel Docs — Configuration & .env
• Laravel Docs — Database Migrations

🚀 What's Next?

With a running project in hand, the next lesson is where the app comes alive: defining routes, wiring them to controllers, capturing URL parameters, and using route model binding to fetch records automatically.