Skip to main content
CF

Messenger! Queue work for Later

5h 5m 31s
English
Paid
Updated September 2026

Messenger! Queue work for Later is a 48-lesson 5 hours 5 minutes self-paced course by SymfonyCasts. Symfony's Messenger component lets you split an application into small message objects and the handlers that act on them, so slow or heavy work can run on a queue instead of blocking the request.

Course facts

Lessons
48
Duration
5 hours 5 minutes
Level
All levels
Language
English
Updated
2026-09-11
Instructor
SymfonyCasts
Price
Premium

Symfony's Messenger component lets you split an application into small message objects and the handlers that act on them, so slow or heavy work can run on a queue instead of blocking the request. This course walks through that idea by building a real feature: automatically dropping a cat photo onto every image a user uploads, processed asynchronously in the background.

What the course covers

  • Writing message and handler classes, then dispatching messages through the bus
  • Setting up transports, routing messages to them, and running worker processes
  • Retrying failed jobs with a dedicated failure transport
  • Adding middleware and message stamps for finer control
  • Prioritized transports and a lightweight CQRS-style query bus

Later sections move toward production concerns: running message handling synchronously for tests, deploying workers with Supervisor, and connecting Messenger to RabbitMQ over AMQP for a proper message broker setup.

Spread across 48 lessons, it suits Symfony developers who already have the framework basics down and want a practical route into asynchronous, queue-based architecture.

Who teaches Messenger! Queue work for Later? SymfonyCasts

SymfonyCasts thumbnail

SymfonyCasts (formerly KnpUniversity) is a US-based PHP / Symfony training platform run by Ryan Weaver, a Symfony core team member. The platform is the closest thing to an official video-tutorial source for the Symfony framework — Ryan's tutorials are the path most working Symfony developers learned the framework through.

The CourseFlix listing carries five SymfonyCasts titles: Symfony 5 Fundamentals — Services, Config & Environments, API Platform — Serious RESTful APIs, Messenger! Queue Work for Later, phpspec — Testing / Designing with a Bite, and the SymfonyCon 2018 Lisbon Conference Videos. Material is paid and aimed at PHP developers building production Symfony applications.

For broader content, see CourseFlix's Symfony and PHP category pages where SymfonyCasts material sits alongside the wider PHP teaching community.

What lessons are included in Messenger! Queue work for Later?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 48 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Installing Messenger
All Course Lessons (48)
#Lesson TitleDurationAccess
1
Installing Messenger Demo
06:15
2
Message, Handler & the Bus
08:36
3
Doing Work in the Handler
06:33
4
Message, Handler & debug:messenger
05:52
5
Transport: Do Work Later (Async)
07:33
6
Worker Command
05:34
7
Problems with Entities in Messages
04:54
8
Passing Entity Ids inside of Messages
08:01
9
Dispatching a Message inside a Handler?
05:30
10
Partial Handler Failures & Advanced Routing
04:36
11
Envelopes & Stamps
06:24
12
Retrying on Failure
05:11
13
Retry Delay & Retry Strategy
04:41
14
The Failure Transport
05:37
15
Investigating & Retrying Failed Messages
05:42
16
Middleware
05:59
17
Tracking Messages with Middleware & a Stamp
05:31
18
Logger Channel Setup and Autowiring
05:27
19
Middleware Message Lifecycle Logging
07:48
20
High Priority Transports
05:41
21
Handling Messages Sync while Developing
05:54
22
Functional Test for the Upload Endpoint
09:23
23
Testing with the "in-memory" Transport
05:26
24
Deployment & Supervisor
09:08
25
Killing Workers Early & on Deploy
05:55
26
Events & Event Bus
05:23
27
Creating & Handling Events
07:55
28
Dispatching the Event & No Handlers
07:07
29
Messenger vs EventDispatcher
03:19
30
Doctrine Transaction & Validation Middleware
05:59
31
Event & Command Bus Organization
07:23
32
Query Bus
08:48
33
Advanced Handler Config: Handler Subscribers
07:59
34
Sending Handlers to Different Transports: from_transport
03:22
35
AMQP with RabbitMQ
07:22
36
AMQP Internals: Exchanges & Queues
08:11
37
AMQP Priority Exchange
07:16
38
Delaying in AMQP: Dead Letter Exchange
07:23
39
Exchange Routing and Binding Keys
06:39
40
Dynamic AMQP Routing Key (AmqpStamp)
07:51
41
Serializing Messages as JSON
06:41
42
JSON, Message Headers & Serializer Options
03:15
43
Setup for Messages from an Outside System
06:01
44
Transport for Consuming External Messages
05:51
45
Custom Transport Serializer
06:34
46
The Lifecycle of a Message & its Stamps
08:17
47
Graceful Failure in the Transport Serializer
04:48
48
Mapping Messages to Classes in a Transport Serializer
04:56
Unlock unlimited learning

Get instant access to all 47 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

What courses are similar to Messenger! Queue work for Later?

More courses by SymfonyCasts

Frequently asked questions

What prerequisites should I have before taking this course?
Before starting this course, you should have a basic understanding of PHP and experience working with Symfony as the Messenger component is part of the Symfony framework. Familiarity with concepts like message queues and asynchronous processing will be beneficial, though not strictly necessary as these are covered in the course through practical examples.
What is the main project or application built in this course?
The primary project in this course involves creating an application that asynchronously adds the cat Ponka to your photos. This project serves as a hands-on exercise in mastering the Symfony Messenger component, teaching you how to create message classes, configure handlers, and manage asynchronous execution through queues and workers.
Who is the target audience for this course?
This course is intended for developers who are already familiar with Symfony and are looking to expand their skills in asynchronous processing and message handling. It's particularly suitable for those interested in learning how to implement the Messenger component to streamline processes and manage task queues effectively.
How does the depth of this course compare to other courses on Symfony components?
This course provides a focused exploration of the Symfony Messenger component, covering advanced topics such as message handling with middleware, managing failure scenarios, and working with RabbitMQ. It offers a deep dive into asynchronous messaging within Symfony, which may not be covered as extensively in more general Symfony courses.
What specific tools or platforms are integrated into the course?
The course integrates RabbitMQ and AMQP, providing detailed lessons on using these tools for effective message queuing and asynchronous processing. You will learn about AMQP internals, exchanges, queues, and priority handling, as well as how to delay messages using the Dead Letter Exchange.
What topics are explicitly not covered in this course?
While the course covers numerous aspects of the Symfony Messenger component, it does not delve into other Symfony components unrelated to messaging. It also does not cover front-end development or user interface design, as its focus is on back-end processing and message handling.
How much time should I expect to commit to this course?
The course consists of 48 lessons, each designed to build on the previous one. Although the total runtime is not specified, you should plan to dedicate several hours per week to go through the lessons, complete exercises, and understand the advanced concepts of the Messenger component, such as middleware and message routing.