Mastering Symfony (SFMASTER)

Prerequisites:

• Participants must have solid experience with Symfony fundamentals, including dependency injection, forms, the HTTP client, and the Serializer component.

• Completion of Advancing with Symfony (or equivalent professional experience) is required.

Learning Objectives:

• Design asynchronous workflows using the Messenger component with retries and failure handling

• Control API output with advanced serialization: metadata, name converters, and circular reference strategies

• Integrate external APIs efficiently using decorators, request multiplexing, and PSR interoperability

• Implement HTTP and application-level caching strategies, including ESI

• Build complex forms with data transformers, mappers, events, and custom themes

• Configure services with advanced dependency injection patterns: factories, service locators, and abstract services

• Create reusable, distributable Symfony bundles with semantic configuration

Assessment Method:

Knowledge is evaluated throughout and at the end of the training course via multiple-choice questions. A certificate of completion is issued upon success, along with attendance documentation. Participants receive one month of access to the online review platform for continued practice.

Day 1 - The Messenger Component

• Messages and handlers: structuring and dispatching work units, synchronously or via a transport

• Message buses: separating command, query, and event buses for clean architecture

• Transports and queue backends: connecting to real queue systems and configuring workers

• Middleware: intercepting and processing messages at each step of the pipeline

• Advanced routing: sending different messages to different transports based on rules

• CQRS: separating read and write operations with dedicated buses and handlers

• Scheduled messages: triggering recurring tasks without an external cron system

• Failure handling and retry strategies: automatically retrying failed messages with backoff policies

Day 2 - Serializer & HttpClient

• Morning - Advanced Serialization

• Metadata vs context: choosing between static attribute configuration and dynamic runtime options

• Selecting and filtering attributes: controlling exactly which fields are exposed per use case

• Name converters: translating property names to match external API conventions

• Handling circular references: strategies for serializing object graphs without infinite loops

• Afternoon — Advanced HttpClient

• Decorators: wrapping the HTTP client for retry, caching, logging, and custom behaviour

• Request multiplexing: sending concurrent HTTP requests and processing responses as they arrive

• PSR interoperability: adapting Symfony's HTTP client to third-party libraries expecting PSR interfaces

Day 3 - Caching & Advanced Forms

• Morning - Caching Strategies

• Application cache vs HTTP cache: understanding the two caching layers and when to use each

• Cache expiration: configuring TTL and max-age for predictable cache lifetimes

• Cache validation: using ETags and Last-Modified headers to avoid stale responses

• Client-side and server-side caching patterns: edge caches, reverse proxies, and CDN integration

• Symfony Cache component: pools, adapters, cache items, and cache tags

• Edge Side Includes (ESI): caching page fragments independently via a reverse proxy

• Afternoon — Advanced Forms

• Data transformers: converting between model data and the form's view representation

• Data mappers: controlling how form data is mapped back to domain objects

• Form events: reacting to the form lifecycle to add, remove, or modify fields dynamically

• Form theming: customising form rendering globally or per form type

• Form type extensions: adding behaviour to existing form types without subclassing

• Unit testing forms: verifying submission, transformation, and validation logic in isolation

Day 4 - Advanced Dependency Injection

• Service factories and configurators: creating and post-processing services with custom logic

• Service locators and service subscribers: lazy-loading collections of services on demand

• Abstract services: defining reusable service templates to reduce configuration duplication

• Lazy services: deferring expensive service instantiation until first use

• Compiler passes: manipulating the container programmatically before it is compiled

Day 5 - Creating Bundles

• Bundle structure and conventions: organising a reusable package for distribution

• Semantic configuration: exposing a clean YAML/PHP API for bundle users

• Configuration validation with the Config component: ensuring user-provided config is correct

• Extension class: loading and wiring services from the bundle's configuration

• Compiler passes in bundles: hooking into the container build at the right moment

• Best practices: optional dependencies, PHP vs YAML config, testing, documentation, and Flex recipes

Global average: 9.3/10

1. Educational rating: 10/10

2. Content rating : 9.3/10

3. Pace rating : 8.5/10

4. Success rate : 100%

The ratings are the synthesis of the cumulative assessments of our trainees from 01/01/2025 to 31/12/2025

Registration can only be made using the registration form available on our website, by phone or via e-mail.

Registration will be completed only after receiving the signed aggreement and the full payment before the start of the training.

Our accessibility guidelines