Vad är Laravel? En komplett guide till PHP-ramverket

Laravel är ett ramverk för PHP som används för att bygga webbapplikationer, API, administrativa system, SaaS-tjänster och andra typer av webbaserade system.

I stället för att en utvecklare behöver bygga grundläggande funktioner för exempelvis routing, databashantering, autentisering, validering, caching och köhantering från början erbjuder Laravel en färdig struktur och ett stort antal verktyg för dessa uppgifter.

Resultatet är att utvecklaren kan lägga mer tid på det som faktiskt är unikt för applikationen.

Den aktuella huvudversionen är Laravel 13, som släpptes den 17 mars 2026. Laravel 13 kräver minst PHP 8.3 och stöder PHP 8.3–8.5. Säkerhetsuppdateringar för versionen är planerade fram till den 17 mars 2028.

I den här guiden går vi igenom hur Laravel fungerar från grunden, vilka delar ramverket består av och hur de samverkar i en riktig applikation.

Laravel i korthet

Laravel är ett så kallat web application framework för PHP.

Ett ramverk kan ses som en färdig teknisk grund för en applikation.

Om du bygger en webbapplikation i ren PHP behöver du själv fatta beslut om och ofta implementera funktionalitet för exempelvis:

URL och routing
anslutning till databasen
SQL-frågor
användarinloggning
sessionshantering
formulärvalidering
behörigheter
felhantering
caching
e-post
bakgrundsjobb
API-autentisering
tester
strukturering av kod

Laravel erbjuder färdiga lösningar och gemensamma konventioner för många av dessa problem.

Ramverket innehåller bland annat routing, middleware, controllers, Blade templates, databashantering, Eloquent ORM, validering, autentisering, caching, köer, events, notifications och ett omfattande kommandoradsverktyg. Den officiella dokumentationen behandlar dessa som centrala delar av Laravel-plattformen.

Laravel kan därför användas både som ett komplett backendramverk och som ett fullstackramverk där Laravel även hanterar delar av frontend.

Vad används Laravel till?

Laravel är inte ett CMS på samma sätt som exempelvis WordPress.

Det är istället en utvecklingsplattform som kan användas för att skapa nästan vilken typ av datadriven webbapplikation som helst.

Vanliga exempel är:

SaaS-applikationer

Laravel lämpar sig väl för system där användare skapar konton och använder en tjänst via webbläsaren.

Det kan exempelvis vara:

CRM-system
projekthantering
bokningssystem
rapportverktyg
analysplattformar
faktureringssystem
medlemsplattformar
interna företagsverktyg

E-handel

Laravel kan användas för att utveckla skräddarsydda e-handelslösningar där ett traditionellt e-handelssystem inte ger tillräcklig flexibilitet.

API

Laravel kan fungera enbart som backend och leverera data till exempelvis:

React
Vue
Svelte
mobilappar
externa system
IoT-enheter
AI-tjänster

Laravel kan automatiskt serialisera Eloquent-modeller till JSON och innehåller dessutom verktyg för strukturerade API-responser. Laravel 13 introducerade även förstapartsstöd för JSON.

Administrativa system

Laravel används ofta när företag behöver ett skräddarsytt administrationsgränssnitt för exempelvis:

kunder
produkter
order
dokument
användare
rapporter
supportärenden
lager
innehåll

Portaler och medlemssystem

Laravel har färdiga byggstenar för autentisering och behörighetskontroll, vilket gör ramverket användbart när olika användare ska kunna se eller göra olika saker i ett system.

Hur fungerar Laravel?

Det blir enklare att förstå Laravel om vi följer vad som händer när någon besöker en sida.

Anta att en användare öppnar:

https://example.com/products/42

Förenklat kan Laravel hantera begäran så här:

Besökare
   ↓
HTTP-request
   ↓
Route
   ↓
Middleware
   ↓
Controller
   ↓
Model / databas
   ↓
Controller
   ↓
View eller JSON
   ↓
HTTP-response
   ↓
Besökare

Det är inte ett krav att alla Laravel-applikationer byggs exakt på detta sätt, men strukturen är mycket vanlig.

Låt oss titta närmare på delarna.

Routing – Laravel bestämmer vad en URL ska göra

Routing handlar om att koppla en URL till kod.

En väldigt enkel Laravel-route kan se ut så här:

use Illuminate\Support\Facades\Route;

Route::get('/', function () {
    return 'Hej världen!';
});

När någon besöker webbplatsens startsida returneras texten:

Hej världen!

En route kan även innehålla parametrar.

Route::get('/users/{id}', function ($id) {
    return 'Användare: ' . $id;
});

Besöker användaren:

/users/25

blir 25 värdet på parametern $id.

I riktiga applikationer placeras större mängder logik normalt inte direkt i routes. Istället skickar routen begäran vidare till en controller.

use App\Http\Controllers\ProductController;

Route::get('/products/{product}', [ProductController::class, 'show']);

Laravel har ett omfattande routingsystem och kan bland annat hantera route-parametrar, route groups, middleware, rate limiting och så kallad route model binding.

Controllers – där HTTP-logiken organiseras

En controller samlar logiken för hur olika HTTP-anrop ska hanteras.

En ProductController skulle exempelvis kunna innehålla metoder för att:

visa produkter
skapa produkter
uppdatera produkter
radera produkter

Laravel placerar normalt controllers i:

app/Http/Controllers/

Du kan skapa en controller med Laravel-kommandot:

php artisan make:controller ProductController

En enkel controller kan se ut så här:

namespace App\Http\Controllers;

use App\Models\Product;

class ProductController extends Controller
{
    public function show(Product $product)
    {
        return view('products.show', [
            'product' => $product
        ]);
    }
}

Laravel kan automatiskt injicera dependencies i controllers genom sin service container. Controllers behöver därför inte själva skapa alla objekt och tjänster de är beroende av.

Models – representationen av dina data

Om applikationen innehåller produkter kan du exempelvis ha modellen:

Product

Har du blogginlägg kan modellen heta:

Post

En användare:

User

Laravel använder normalt Eloquent ORM för att låta modeller kommunicera med databasen.

Det betyder att du ofta kan arbeta med PHP-objekt istället för att skriva SQL manuellt.

Vad är Eloquent ORM?

Eloquent är Laravels inbyggda ORM, vilket står för Object-Relational Mapping.

Grundidén är att en tabell i databasen representeras av en PHP-klass.

Har du tabellen:

products

kan den exempelvis representeras av:

class Product extends Model
{
    //
}

Laravel beskriver Eloquent som ett ORM där varje databastabell har en motsvarande modell som kan användas för att hämta, skapa, uppdatera och radera poster.

Istället för SQL:

SELECT * FROM products WHERE id = 42;

kan du exempelvis skriva:

$product = Product::find(42);

För att hitta alla aktiva produkter:

$products = Product::where('active', true)->get();

För att skapa en produkt:

$product = Product::create([
    'name' => 'Trådlöst tangentbord',
    'price' => 899,
]);

Det går fortfarande att använda rå SQL eller Laravels Query Builder när det behövs. Laravel stöder alltså flera nivåer av databasinteraktion: rå SQL, Query Builder och Eloquent ORM.

Relationer mellan data

En stor styrka med ett ORM blir tydlig när olika typer av information hör ihop.

Anta att vi har:

User
Post
Comment

En användare kan ha flera blogginlägg.

Ett blogginlägg kan ha flera kommentarer.

I en User-modell skulle relationen kunna definieras:

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

Sedan kan vi hämta användarens inlägg:

$user->posts;

eller bygga vidare på relationen:

$user->posts()
    ->where('published', true)
    ->latest()
    ->get();

Laravel stöder bland annat one-to-one, one-to-many, many-to-many och flera mer avancerade relationstyper. Relationerna fungerar dessutom som query builders, vilket gör att ytterligare villkor kan kedjas direkt på relationen.

Databaser som Laravel stöder

Laravel 13 har förstapartsstöd för:

MariaDB
MySQL
PostgreSQL
SQLite
Microsoft SQL Server

MongoDB kan också användas via ett officiellt MongoDB-paket för Laravel.

En ny Laravel-applikation använder som standard SQLite, vilket gör att det går att börja utveckla utan att först konfigurera en separat databasserver.

För större produktionssystem är exempelvis MySQL och PostgreSQL vanliga alternativ.

Migrations – versionshantering för databasen

Laravel använder migrations för att beskriva databasens struktur i kod.

Istället för att manuellt skapa tabeller i databasen kan en utvecklare skapa en migration.

php artisan make:migration create_posts_table

En förenklad migration kan se ut så här:

Schema::create('posts', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->string('slug')->unique();
    $table->text('content');
    $table->timestamp('published_at')->nullable();
    $table->timestamps();
});

Sedan körs:

php artisan migrate

Laravel skapar då tabellen.

Det här är betydligt viktigare än det först kan verka.

Databasens struktur blir en del av projektets kodbas och kan versionshanteras tillsammans med resten av applikationen.

En ny utvecklare behöver alltså inte få instruktionen:

Skapa manuellt de här 14 tabellerna och lägg till de här 37 kolumnerna.

Utvecklaren kan istället installera projektet och köra migrations.

Blade – Laravels templatesystem

Om Laravel även ska rendera HTML kan man använda Blade, Laravels templatespråk.

Blade-filer har normalt filändelsen:

.blade.php

och ligger i:

resources/views/

En enkel Blade-template kan se ut så här:

<h1>{{ $product->name }}</h1>

<p>{{ $product->description }}</p>

<p>Pris: {{ $product->price }} kr</p>

Vill du loopa igenom flera produkter:

@foreach ($products as $product)
    <article>
        <h2>{{ $product->name }}</h2>
        <p>{{ $product->description }}</p>
    </article>
@endforeach

Blade stödjer bland annat:

@if
@foreach
@for
@switch
@include
@extends
@section
@yield

och komponenter.

Blade separerar presentationslogiken från exempelvis controllerlogiken. Laravel kompilerar Blade-templates innan de används för att generera HTML.

Måste frontend byggas med Blade?

Nej.

Det är en viktig skillnad mellan Laravel och många enklare PHP-system.

Du kan använda Laravel på flera sätt.

Laravel + Blade

En traditionell Laravel-applikation kan använda:

Laravel
+
Blade
+
JavaScript vid behov

Det passar bra när Laravel renderar hela webbplatsen.

Laravel + React

Laravel kan också kombineras med React.

Laravel backend
+
React frontend

Laravel + Vue

På samma sätt:

Laravel backend
+
Vue frontend

Laravel som API

Laravel kan även användas helt utan att rendera användargränssnittet:

Mobilapp
      ↓
Laravel API
      ↓
Databas

eller:

React
   ↓
Laravel API
   ↓
Databas

Laravel beskriver sig självt både som ett fullstackramverk och som ett API-backendramverk beroende på hur applikationen ska byggas.

Vad är Artisan?

Artisan är Laravels kommandoradsverktyg.

Istället för att skapa alla filer manuellt kan du låta Laravel generera mycket av grundstrukturen.

Exempel:

php artisan make:model Product

skapar en model.

php artisan make:controller ProductController

skapar en controller.

php artisan make:migration create_products_table

skapar en migration.

Andra vanliga kommandon är:

php artisan migrate

php artisan route:list

php artisan cache:clear

php artisan config:clear

php artisan make:middleware CheckSubscription

php artisan make:job ProcessOrder

Artisan blir snabbt en central del av det dagliga arbetet i Laravel.

Så installerar du Laravel

För Laravel 13 behöver du minst PHP 8.3.

Laravel rekommenderar även:

PHP
Composer
Laravel Installer
Node.js + NPM eller Bun för frontend-assets

Detta framgår av den officiella installationsguiden för Laravel 13.

Om PHP och Composer redan finns installerat kan Laravel Installer installeras med:

composer global require laravel/installer

Skapa sedan ett nytt projekt:

laravel new my-app

Gå in i projektet:

cd my-app

Installera och bygg frontend-assets:

npm install
npm run build

Starta utvecklingsmiljön:

composer run dev

Den lokala applikationen blir därefter tillgänglig via:

http://localhost:8000

Det aktuella dev-scriptet kan starta Laravels lokala server, queue worker och Vite-utvecklingsserver tillsammans.

Hur ser ett Laravel-projekt ut?

Ett nytt projekt innehåller bland annat mappar som:

app/
bootstrap/
config/
database/
public/
resources/
routes/
storage/
tests/
vendor/

De viktigaste i början är följande.

app/

Här finns en stor del av applikationens PHP-kod.

Exempel:

app/Models/
app/Http/Controllers/

routes/

Här definieras applikationens routes.

Exempelvis:

routes/web.php

resources/

Här ligger bland annat Blade-templates och frontend-resurser.

resources/views/

database/

Här finns bland annat:

migrations
factories
seeders

config/

Här ligger Laravels konfigurationsfiler.

public/

Detta är webbserverns publika katalog och innehåller bland annat applikationens index.php.

Webbservern ska peka mot Laravels public-katalog och inte mot projektets rot, eftersom andra delar av Laravel-projektet kan innehålla information som aldrig ska exponeras publikt.

storage/

Här kan Laravel bland annat lagra:

loggar
cachade templates
sessionsdata
genererade filer

tests/

Här ligger automatiserade tester.

Vad är .env-filen?

I roten av ett Laravel-projekt finns normalt:

.env

Den innehåller miljöspecifik konfiguration.

Exempel:

APP_NAME="My App"
APP_ENV=local
APP_DEBUG=true

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=my_app
DB_USERNAME=root
DB_PASSWORD=

.env används bland annat för:

databasuppgifter
API-nycklar
e-postkonfiguration
cache
externa tjänster
applikationsmiljö

En .env-fil ska inte läggas i Git eller annan publik versionshantering, eftersom den kan innehålla lösenord, API-nycklar och andra hemligheter. Laravel varnar uttryckligen för detta i installationsdokumentationen.

Validering i Laravel

Data från en användare ska aldrig förutsättas vara korrekt.

Anta att en användare skapar en produkt.

Vi kanske kräver:

namn
pris
giltigt pris
maximalt 255 tecken i namnet

Laravel kan validera detta:

$validated = $request->validate([
    'name' => ['required', 'string', 'max:255'],
    'price' => ['required', 'numeric', 'min:0'],
]);

Om valideringen misslyckas hanterar Laravel processen och returnerar ett lämpligt valideringsfel.

Laravel innehåller ett stort bibliotek av färdiga valideringsregler och stödjer även egna regler.

När valideringen blir större kan den flyttas till separata Form Request-klasser.

Det håller controllers renare och gör valideringslogiken enklare att återanvända och testa.

Middleware – kontrollstationer för requests

Middleware ligger mellan inkommande HTTP-request och själva applikationslogiken.

Tänk:

Request
   ↓
Middleware
   ↓
Controller

Middleware kan exempelvis kontrollera:

Är användaren inloggad?

Har användaren rätt roll?

Kommer requesten från en tillåten domän?

Ska requesten rate-limitas?

Har användaren accepterat vissa villkor?

Laravel använder middleware för att inspektera och filtrera HTTP-requests innan de går vidare i applikationen.

Exempel:

Route::get('/dashboard', function () {
    return view('dashboard');
})->middleware('auth');

Nu måste användaren vara autentiserad för att få tillgång till /dashboard.

Autentisering – inloggning och användarkonton

Att implementera säker användarinloggning från grunden är inte något man bör göra lättvindigt.

Laravel har därför ett omfattande autentiseringssystem och färdiga starter kits som kan ge en applikation grundläggande funktionalitet för exempelvis registrering och inloggning.

Laravel skiljer dessutom mellan authentication och authorization.

Authentication besvarar frågan:

Vem är användaren?

Authorization besvarar frågan:

Vad får användaren göra?

En användare kan alltså vara inloggad men ändå sakna rättighet att exempelvis radera en viss produkt eller redigera en annan användares artikel. Laravel erbjuder bland annat policies och gates för sådana kontroller.

Laravel Sanctum och API-autentisering

Om Laravel används som API måste klienten ofta kunna identifiera sig.

Här är Laravel Sanctum ett vanligt alternativ.

Sanctum är framtaget för bland annat:

SPA-applikationer
mobilappar
enklare tokenbaserade API

Det kan hantera både session/cookie-baserad autentisering och API-tokens.

Om applikationen specifikt kräver full OAuth2-funktionalitet erbjuder Laravel istället Passport.

Laravel rekommenderar generellt Sanctum när OAuth2-funktionerna i Passport inte faktiskt behövs.

Queues – flytta långsamma jobb till bakgrunden

Anta att en användare beställer en rapport.

Rapporten tar 20 sekunder att generera.

Ett dåligt upplägg skulle kunna vara:

Användaren klickar
↓
väntar 20 sekunder
↓
servern genererar rapporten
↓
sidan svarar

En bättre lösning kan vara:

Användaren klickar
↓
jobbet läggs i en queue
↓
användaren får svar direkt

Bakgrund:
Queue worker
↓
genererar rapporten
↓
skickar notification

Laravel har ett gemensamt queue-API som kan arbeta med flera backend-system, däribland Redis, Amazon SQS och relationsdatabaser.

Queues används ofta för:

e-post
bildbearbetning
importer
exporter
rapportgenerering
externa API-anrop
AI-bearbetning
stora datamängder

Ett jobb kan exempelvis skapas med:

php artisan make:job GenerateReport

Cache – slipp göra samma arbete om och om igen

Anta att en tung databasfråga tar två sekunder men resultatet bara behöver räknas om var tionde minut.

Istället för:

Besökare 1 → databasfråga
Besökare 2 → databasfråga
Besökare 3 → databasfråga
Besökare 4 → databasfråga

kan vi göra:

Första besökaren
↓
databasfråga
↓
cache

Nästa besökare
↓
cache

Laravel har ett gemensamt cache-API och stödjer bland annat Redis, Memcached, DynamoDB, relationsdatabaser och filsystem som cache-backends.

Det gör att själva applikationskoden kan förbli relativt lik även om infrastrukturen bakom cachen förändras.

Notifications och e-post

Laravel innehåller även system för notifications.

En notification kan exempelvis vara:

Din order har skickats.

eller:

Din rapport är klar.

Notifications kan användas mot olika kommunikationskanaler och Laravel har även ett separat mailsystem för mer traditionella e-postmeddelanden.

E-post kan dessutom skickas via en queue istället för under själva webbrequesten.

Det betyder att användaren slipper vänta på att e-postleverantören ska svara innan sidan kan fortsätta.

Service Container och dependency injection

När man kommit lite längre med Laravel stöter man snabbt på Service Container.

Service Container ansvarar för att skapa och koppla ihop objekt och deras beroenden.

Anta att vi har:

class OrderController
{
    public function __construct(
        protected PaymentService $paymentService
    ) {}
}

Laravel kan automatiskt förstå att OrderController behöver en PaymentService och injicera den när controllern skapas.

Detta kallas dependency injection.

Laravels service container är en central del av ramverkets arkitektur och kan automatiskt lösa många konkreta klassberoenden utan separat konfiguration. Den implementerar även PSR-11-gränssnittet.

För större applikationer gör detta det enklare att separera ansvar och skriva kod som går att testa och byta ut.

Laravel och automatiserade tester

Laravel har inbyggt stöd för automatiserade tester.

Det är möjligt att testa exempelvis:

HTTP-endpoints
databaslogik
autentisering
validering
API-responser
jobs
events
notifications
mail

Ett enkelt HTTP-test kan exempelvis kontrollera att startsidan fungerar:

test('startsidan fungerar', function () {
    $response = $this->get('/');

    $response->assertStatus(200);
});

Du kan även kontrollera att en användare måste vara inloggad:

test('gäster kan inte se dashboard', function () {
    $response = $this->get('/dashboard');

    $response->assertRedirect('/login');
});

Laravel använder en separat testing-miljö vid tester och konfigurerar bland annat session och cache så att testdata inte ligger kvar mellan körningarna.

Laravel 13 och AI

Laravel har under 2026 tagit ett betydligt tydligare steg mot AI-utveckling.

Laravel 13 introducerade ett officiellt Laravel AI SDK.

SDK erbjuder ett Laravel-anpassat gränssnitt för bland annat:

textgenerering
AI-agenter
tool calling
embeddings
bilder
ljud
vector stores

Tanken är att utvecklaren ska kunna bygga AI-funktionalitet genom ett gemensamt Laravel-API istället för att knyta hela applikationen direkt till en enskild AI-leverantör.

Laravel 13 innehåller exempelvis stöd för embeddings som kan användas för semantisk sökning och retrieval-baserade system.

Det gör moderna användningsområden möjliga, exempelvis:

Användarens fråga
       ↓
Laravel
       ↓
Skapa embedding
       ↓
Semantisk sökning
       ↓
Hitta relevanta dokument
       ↓
AI-modell
       ↓
Svar

Laravel har dessutom separat stöd för MCP – Model Context Protocol, vilket gör det möjligt att exponera Laravel-funktioner som tools, resources och prompts till AI-klienter.

Det här gör AI till en allt mer integrerad del av Laravel-ekosystemet snarare än något som alltid behöver byggas helt utanför ramverket.

Ett enkelt Laravel-projekt från början till slut

Låt oss knyta ihop delarna genom att skapa grunden till en enkel blogg.

1. Skapa projektet

laravel new my-blog

Gå in i katalogen:

cd my-blog

2. Skapa modellen

php artisan make:model Post -m

Det skapar modellen:

app/Models/Post.php

och en migration.

3. Definiera databasen

Migrationen kan exempelvis innehålla:

Schema::create('posts', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->string('slug')->unique();
    $table->text('excerpt')->nullable();
    $table->longText('content');
    $table->timestamp('published_at')->nullable();
    $table->timestamps();
});

Kör:

php artisan migrate

Nu finns tabellen posts.

4. Skapa en controller

php artisan make:controller PostController

Vi kan sedan skapa en metod för artikellistan:

use App\Models\Post;

public function index()
{
    $posts = Post::query()
        ->whereNotNull('published_at')
        ->where('published_at', '<=', now())
        ->latest('published_at')
        ->paginate(10);

    return view('posts.index', [
        'posts' => $posts,
    ]);
}

5. Skapa routen

I routes/web.php:

use App\Http\Controllers\PostController;

Route::get('/artiklar', [PostController::class, 'index']);

6. Skapa Blade-vyn

<h1>Senaste artiklarna</h1>

@foreach ($posts as $post)

    <article>

        <h2>
            {{ $post->title }}
        </h2>

        <p>
            {{ $post->excerpt }}
        </p>

    </article>

@endforeach

{{ $posts->links() }}

Nu har vi ett väldigt enkelt men komplett flöde:

/artiklar
    ↓
Route
    ↓
PostController
    ↓
Post-modellen
    ↓
Databas
    ↓
Blade
    ↓
HTML

Det är i grunden så många Laravel-applikationer fungerar.

När projektet växer kan vi sedan lägga till:

Authentication
Middleware
Policies
API
Queues
Cache
Events
Notifications
Tests
Search
AI

utan att behöva byta teknisk grund.

Fördelar med Laravel

Laravel har flera egenskaper som gjort ramverket användbart för både mindre och betydligt större webbapplikationer.

Många vanliga problem är redan lösta

Utvecklare behöver inte själva skapa grundläggande system för routing, sessionshantering, validation, caching, queues och liknande.

Tydliga konventioner

När utvecklare känner till Laravel vet de ofta ungefär var olika typer av kod ska finnas.

Det gör projekt enklare att sätta sig in i jämfört med helt ostrukturerade PHP-applikationer.

Eloquent gör databaser lättillgängliga

Vanliga databasoperationer kan uttryckas med relativt lättläst PHP.

Stort ekosystem

Laravel är betydligt mer än själva framework-paketet.

Det officiella ekosystemet omfattar idag verktyg för bland annat queues, autentisering, realtid, deployment, monitoring, AI, search och utvecklingsmiljöer. Den officiella Laravel 13-dokumentationen listar exempelvis Sanctum, Passport, Horizon, Sail, Scout, Socialite, Telescope, Pulse och flera andra förstapartsverktyg och paket.

Bra stöd för både små och avancerade lösningar

Du behöver inte använda allt.

En enkel webbplats kan bestå av:

Routes
Controllers
Eloquent
Blade

medan en större applikation kan använda:

Redis
Queues
Events
APIs
WebSockets
Workers
Caching
Search
AI
Multiple databases

under samma ramverk.

Nackdelar med Laravel

Laravel är inte automatiskt rätt val för alla projekt.

Laravel är större än ren PHP

Om du bara behöver en extremt enkel PHP-sida kan ett komplett ramverk innebära mer struktur och fler beroenden än vad problemet kräver.

Det finns mycket att lära sig

En ny Laravel-utvecklare behöver med tiden förstå begrepp som:

routing
middleware
Eloquent
migrations
service container
dependency injection
queues
service providers
events
facades
policies

Laravel försöker göra enkla saker enkla, men avancerade applikationer kräver fortfarande god förståelse för PHP och webbarkitektur.

Eloquent kan missbrukas

ORM-system gör databaskod bekväm, men de eliminerar inte behovet av databaskunskap.

En utvecklare behöver fortfarande förstå exempelvis:

index
joins
relationsdesign
query performance
transactions
N+1-problem

Att en databasfråga är enkel att skriva betyder inte automatiskt att den är effektiv.

Ett ramverk ersätter inte arkitektur

Laravel ger dig verktygen.

Det bestämmer inte automatiskt hur en komplex applikations affärslogik bör struktureras.

En dåligt designad applikation kan fortfarande bli dålig – även om den är byggd i Laravel.

Laravel jämfört med WordPress

Laravel och WordPress blandas ibland ihop eftersom båda använder PHP.

Men de löser olika problem.

WordPress är i första hand ett CMS.

Det kommer med ett färdigt system för exempelvis:

sidor
inlägg
användare
mediabibliotek
administration
teman
plugins

Laravel är istället ett ramverk för att utveckla själva applikationen.

Om uppgiften är:

Vi behöver en vanlig företagswebbplats med artiklar.

då är WordPress ofta ett mer direkt verktyg.

Om uppgiften istället är:

Vi behöver en unik plattform där kunder loggar in, laddar upp dokument, bearbetar data, genererar rapporter och betalar efter användning.

då ligger problemet betydligt närmare det Laravel är byggt för.

Laravel jämfört med att skriva PHP från grunden

Det är fullt möjligt att bygga webbapplikationer utan Laravel.

Du kan själv skriva:

$db = new PDO(...);

bygga routing, skapa autentisering och strukturera hela systemet.

Problemet uppstår när applikationen växer.

Du börjar då i praktiken skapa ditt eget lilla ramverk:

egen router
egen validation
egen database layer
egen auth
egen error handling
egen dependency management

Laravel erbjuder istället en etablerad struktur för många av problemen redan från början.

Det innebär inte att Laravel alltid är bättre.

Det betyder att utvecklaren slipper lösa samma infrastrukturella problem på nytt i varje projekt.

Är Laravel ett MVC-ramverk?

Laravel beskrivs ofta som ett MVC-ramverk.

MVC står för:

Model
View
Controller

och modellen passar många Laravel-applikationer bra.

Model

Ansvarar huvudsakligen för data.

Product
User
Order

View

Visar informationen.

Exempel:

Blade

Controller

Tar emot requesten och koordinerar vad som ska göras.

Men moderna Laravel-applikationer består ofta av betydligt fler typer av komponenter:

Models
Controllers
Jobs
Events
Listeners
Policies
Services
Notifications
Commands
Middleware
Requests
Resources

Att bara tänka “MVC” ger därför inte hela bilden av hur en större Laravel-applikation är uppbyggd.

Är Laravel säkert?

Laravel innehåller flera säkerhetsmekanismer och abstraherar bort många vanliga riskområden.

Exempelvis använder Laravels Query Builder PDO parameter binding för query-parametrar, vilket skyddar dessa queries mot SQL injection när API används korrekt.

Laravel innehåller även mekanismer för bland annat:

CSRF/request forgery-skydd
password hashing
autentisering
authorization
sessions
validation
rate limiting

Laravel 13 förstärkte dessutom sitt request forgery-skydd med origin-aware request verification samtidigt som det traditionella tokenbaserade CSRF-skyddet behölls.

Men ett ramverk gör inte automatiskt en applikation säker.

Utvecklaren måste fortfarande hantera exempelvis:

behörigheter
känsliga API-nycklar
serverkonfiguration
filuppladdningar
tredjepartsbibliotek
användardata
säkerhetsuppdateringar

korrekt.

Är Laravel snabbt?

Frågan “är Laravel snabbt?” saknar egentligen ett enkelt ja- eller nej-svar.

Prestandan i en verklig applikation påverkas av betydligt mer än valet av ramverk:

Databasfrågor
Caching
Server
PHP-konfiguration
Antal externa API-anrop
Frontend
Redis
Queues
Kodens arkitektur
Datamängder

En dålig databasfråga som körs 1 000 gånger blir inte snabb bara för att den ligger i Laravel.

Samtidigt erbjuder Laravel verktyg för exempelvis caching, queues och andra tekniker som kan användas för att flytta eller minska dyrt arbete.

Den relevanta frågan är därför oftast inte:

Är Laravel snabbt?

utan:

Är Laravel-applikationen korrekt byggd för den belastning den ska hantera?

Vem bör lära sig Laravel?

Laravel är särskilt relevant om du:

redan kan grunderna i PHP
vill utveckla moderna webbapplikationer
vill bygga API
vill utveckla SaaS-produkter
behöver bygga skräddarsydda affärssystem
vill arbeta mer strukturerat än med fristående PHP-filer
vill kombinera PHP med React, Vue eller andra frontend-tekniker
vill bygga applikationer med AI-funktioner i PHP

Har du aldrig programmerat tidigare är det däremot klokt att först förstå grunderna i:

PHP
HTML
HTTP
databaser
SQL
objektorienterad programmering

Annars är det lätt att lära sig vilka Laravel-kommandon man ska skriva utan att förstå vad Laravel faktiskt gör.

Är Laravel fortfarande relevant 2026?

Ja.

Laravel 13 släpptes i mars 2026 och projektet fortsätter att få både nya framework-funktioner och ett växande ekosystem. Version 13 har planerade buggrättningar till tredje kvartalet 2027 och säkerhetsuppdateringar till mars 2028.

Särskilt intressant är att Laravel inte enbart utvecklas kring traditionell PHP-webbutveckling.

Laravel 13 innehåller bland annat förstapartsfunktionalitet för:

AI
agents
embeddings
vector search
JSON
MCP
modern queue-hantering

Det visar att Laravel aktivt försöker fungera som en plattform även för nya typer av applikationer.

Vanliga frågor om Laravel

Vad är Laravel?

Laravel är ett webbramverk för PHP som ger utvecklare färdiga verktyg och strukturer för att bygga webbapplikationer och API. Det innehåller bland annat routing, controllers, Eloquent ORM, Blade, validation, authentication, caching och queues.

Vilket programmeringsspråk använder Laravel?

Laravel är skrivet för PHP och Laravel-applikationer utvecklas huvudsakligen i PHP. Laravel 13 kräver minst PHP 8.3.

Är Laravel gratis?

Laravel Framework är open source och dess källkod distribueras under MIT-licensen. Vissa tjänster och produkter i Laravel-ekosystemet kan däremot vara kommersiella.

Är Laravel ett CMS?

Nej. Laravel är ett ramverk för att utveckla applikationer. Det levereras inte som ett färdigt innehållshanteringssystem på samma sätt som exempelvis WordPress.

Kan Laravel användas för API?

Ja. Laravel kan användas som backend för exempelvis webbappar och mobilappar. Laravel erbjuder API-autentisering genom bland annat Sanctum och Passport och kan returnera modeller och resurser som JSON.

Kan Laravel användas med React?

Ja. Laravel kan fungera som backend till React, antingen genom en API-baserad arkitektur eller genom en mer integrerad fullstacklösning.

Kan Laravel användas med Vue?

Ja. Vue kan användas som frontend tillsammans med Laravel på motsvarande sätt.

Vilken databas använder Laravel?

Laravel kan användas med flera databaser. Laravel 13 har förstapartsstöd för MariaDB, MySQL, PostgreSQL, SQLite och Microsoft SQL Server. Nya Laravel-applikationer konfigureras som standard med SQLite.

Vad är Eloquent?

Eloquent är Laravels ORM. Det kopplar PHP-modeller till databastabeller och gör det möjligt att läsa och manipulera databasdata genom modeller och PHP-metoder.

Vad är Blade?

Blade är Laravels templatesystem för att skapa HTML-vyer. Blade-filer använder normalt filändelsen .blade.php.

Vad är Artisan?

Artisan är kommandoradsverktyget som följer med Laravel. Det används bland annat för att skapa klasser, köra migrations, inspektera routes och utföra administrativa uppgifter i applikationen.

Vad är den senaste versionen av Laravel?

Den aktuella stabila huvudversionen är Laravel 13. Den släpptes den 17 mars 2026 och kräver PHP 8.3 eller senare.

Kan man bygga AI-applikationer med Laravel?

Ja. Laravel 13 introducerade Laravel AI SDK med stöd för bland annat textgenerering, agents, tool calling, embeddings, bilder, ljud och vector stores. Laravel har även stöd för Model Context Protocol, MCP.

Sammanfattning

Laravel är i grunden ett sätt att slippa börja från noll varje gång en PHP-applikation ska byggas.

Ramverket ger en struktur för hur en applikation kan hantera:

HTTP-requests
↓
Routing
↓
Middleware
↓
Controllers
↓
Affärslogik
↓
Eloquent / databas
↓
Views eller API-responser

Runt denna kärna finns sedan system för bland annat:

autentisering
behörigheter
validation
cache
queues
notifications
events
API
tester
search
realtid
AI

Det är denna kombination som är viktigare än någon enskild Laravel-funktion.

Laravel är inte bara ett bibliotek som hjälper dig skriva PHP snabbare. Det ger en gemensam arkitektur, ett ekosystem och ett antal etablerade lösningar för problem som återkommer i nästan alla större webbapplikationer.

För en ny utvecklare är därför den bästa vägen inte att försöka lära sig alla Laravel-funktioner på en gång.

Börja istället med att förstå kedjan:

Route → Controller → Model → Database → View

När den sitter blir nästa steg – Eloquent-relationer, validation, authentication, middleware, queues, APIs och slutligen mer avancerade delar av Laravel – betydligt enklare att förstå.