Laravel vs Symfony: Choosing a Framework

After learning plain PHP, the next question every student asks is "Laravel or Symfony?". Job listings in India mention Laravel most often, while many larger companies, product firms and European clients use Symfony. Both are excellent, both are free and open source, and both are built on the ideas you already know from this course: Composer, PSR-4 autoloading, a front controller, dependency injection and PDO underneath.

In this lesson you will see the same small JSON endpoint written in plain PHP, Laravel and Symfony, compare how the two frameworks are organised and supported, and learn a practical way to choose for a project or a career. Introduction to Laravel covers Laravel itself in more depth.

What a framework gives you

A framework is a ready-made structure plus a large set of tested components: routing, request and response objects, validation, templates, database access, migrations, authentication, queues, email, caching and testing helpers. You write the parts that are specific to your app; the framework handles the rest in a consistent way.

The cost is that you must learn the framework's conventions, keep it updated, and accept some extra code and memory per request. For a five-page site with one contact form, that cost is not worth paying. For an app with logins, roles, an admin panel, an API and background jobs, it almost always is.

The same endpoint three ways

The task: GET /api/students/7 returns one student as JSON, or a 404.

Plain PHP (as in Building a REST API): you write the routing, the query and the JSON response yourself.

<?php
declare(strict_types=1);

// public/index.php (simplified)
$path = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);

if ($_SERVER['REQUEST_METHOD'] === 'GET' && preg_match('#^/api/students/(\d+)$#', $path, $m)) {
    $stmt = db()->prepare('SELECT id, name, city FROM students WHERE id = :id');
    $stmt->execute(['id' => (int) $m[1]]);
    $student = $stmt->fetch();

    header('Content-Type: application/json');
    if ($student === false) {
        http_response_code(404);
        echo json_encode(['error' => 'Student not found']);
        exit;
    }
    echo json_encode($student);
}

Laravel 13: a route file maps the URL to a controller method, and route model binding loads the Student Eloquent model from the {student} id automatically, answering 404 by itself when it does not exist.

<?php
// routes/api.php  (create it with: php artisan install:api)
use App\Http\Controllers\StudentController;
use Illuminate\Support\Facades\Route;

Route::get('/students/{student}', [StudentController::class, 'show']);

<?php
// app/Http/Controllers/StudentController.php
namespace App\Http\Controllers;

use App\Models\Student;
use Illuminate\Http\JsonResponse;

class StudentController extends Controller
{
    public function show(Student $student): JsonResponse
    {
        return response()->json([
            'id' => $student->id,
            'name' => $student->name,
            'city' => $student->city,
        ]);
    }
}

Symfony 8: the route is an attribute on the controller method (see Attributes & Reflection), and the Doctrine repository is injected by the dependency injection container.

<?php
// src/Controller/StudentController.php
namespace App\Controller;

use App\Repository\StudentRepository;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\Routing\Attribute\Route;

final class StudentController extends AbstractController
{
    #[Route('/api/students/{id}', name: 'student_show', methods: ['GET'], requirements: ['id' => '\d+'])]
    public function show(int $id, StudentRepository $students): JsonResponse
    {
        $student = $students->find($id);
        if ($student === null) {
            throw $this->createNotFoundException('Student not found');
        }

        return $this->json([
            'id' => $student->getId(),
            'name' => $student->getName(),
            'city' => $student->getCity(),
        ]);
    }
}

All three give the same answer to a client:

curl http://localhost:8000/api/students/7

{"id":7,"name":"Meera","city":"Kochi"}

Notice what changes. Laravel hides more: one line of routing, the model is found for you, and helpers like response() are always available. Symfony is more explicit: you see the route, the types and every dependency in the method signature. Neither is "better"; they reflect different philosophies.

Side by side

Two facts make the choice less scary. First, Laravel is built on Symfony components: its HTTP layer, console, mailer and more come from Symfony, so skills transfer both ways. Second, Symfony components work alone in any project: composer require symfony/mailer or symfony/console in a plain PHP app is common.

Other names you will meet

• CodeIgniter 4: a small, fast framework that many Indian companies and colleges have used for years; easy to learn, with less built in.
• Slim and Mezzio: micro-frameworks built around PSR-7 and PSR-15 middleware (PSR Standards in Practice); good for small APIs.
• WordPress, Drupal, Magento (Adobe Commerce) and Moodle: not general frameworks but platforms. A huge share of PHP jobs is building plugins, themes and extensions for them. Drupal is itself built on Symfony components.
• Yii and CakePHP: older full-stack frameworks still running many business apps.

How to choose

For a project, ask four questions:

1. How big and how long-lived? A landing page or tiny tool: plain PHP or Slim. A full app with logins, roles and an API: a framework.
2. What does the team already know? A team fluent in one framework ships faster with it than with a "better" one.
3. How often can you upgrade? Yearly upgrades are routine in Laravel; Symfony LTS allows longer gaps.
4. What does hosting allow? Both need Composer and a recent PHP. Symfony 8 needs PHP 8.4, which some shared hosts do not offer yet; Laravel 13 needs 8.3.

For a career, look at job listings in the city where you want to work. In most Indian cities Laravel appears far more often, so it is the practical first choice; Symfony knowledge stands out for product companies and overseas clients. Either way, the plain-PHP skills from this course (OOP, Composer, PDO, security, testing) are what interviewers check, because they show you understand what the framework does for you.

Common mistakes

• Learning a framework before PHP itself. Without plain PHP, framework "magic" becomes guesswork and debugging is painful.
• Following tutorials for old versions. Laravel 8 or Symfony 4 code often fails on current versions. Check the date and version of every tutorial.
• Fighting the conventions. Putting files where the framework does not expect them makes upgrades and teamwork harder.
• Picking a framework for a tiny site. A brochure site does not need a queue system.

Key points

• Frameworks provide routing, validation, ORM, templates, auth, queues and testing tools so you write only app-specific code.
• Laravel favours convention and speed; Symfony favours explicitness, configuration and reusable components.
• Laravel 13 needs PHP 8.3 and releases a major version yearly; Symfony 8.1 needs PHP 8.4, with LTS versions such as 7.4 supported for years.
• Laravel uses many Symfony components, and Symfony components work in plain PHP projects too.
• Choose by project size, team knowledge, upgrade budget and hosting; for jobs, check local listings.