Laravel Advanced
Laravel Advanced is an advanced course on Laravel 13 covering the service container, advanced Eloquent, queues with Redis and Horizon, events, SOLID principles, design patterns, testing with Pest and TDD, package development and CI/CD with GitHub Actions. It suits developers already using Laravel at work and teams looking after larger Laravel systems.
- Duration30 hours · 5 days
- FormatOnsite / live online
- Next roundOn request
- CertificateIncluded
Course overview
Once you can build a website with Laravel, the next challenge is making it cope with larger, real workloads. Long-running tasks have to move into the background with queues, controllers that keep growing must be split into testable pieces, and the team needs tests and a pipeline so the system can change without fear of breaking it. Understanding the service container, SOLID principles and design patterns is what separates developers who can use Laravel from those who can confidently look after a large Laravel system.
This course builds on basic Laravel using Laravel 13 and PHP 8.5. It starts with how the service container works, advanced routing and Eloquent, queues with Redis and Horizon, events, notifications and the scheduler. Learners then structure code with SOLID, repositories and design patterns, write tests with Pest and practise TDD from unit tests to browser tests, develop their own package and set up CI/CD with GitHub Actions. The course closes with a capstone that brings everything together. (5 days, 6 hours per day, 30 hours in total, Advanced level.)
What you’ll gain
- Understand how the service container, service providers and facades work, and use them to design code
- Use advanced routing, form requests and Eloquent features such as polymorphic relationships and custom casts
- Design background work with queues, Redis and Horizon, and keep workers running on a server with Supervisor
- Use events, listeners, notifications, Artisan commands and task scheduling where they fit
- Structure code following SOLID with repositories, services, action classes and design patterns
- Write unit, feature, browser and architecture tests with Pest and work test-first
- Extract code into a package, test it and reuse it across projects
- Set up CI/CD with GitHub Actions to check code and run tests on every change
Who this course is for
- Web developers who use Laravel at work and want to take it further
- Programmers maintaining large Laravel systems who want a structure that is easier to look after
- In-house IT and development teams setting code and testing standards
- Tech leads who review code and set up pipelines for a Laravel team
- Learners who have completed Basic Laravel for Beginners
Prerequisites
- Completion of a basic Laravel course, or able to build a site with Laravel routes, controllers, Blade and Eloquent
- An understanding of object-oriented PHP, such as classes, interfaces and namespaces
- Comfortable with Git, Composer and the command line
- A laptop that can run PHP 8.3 or later, Composer, Node.js, Redis and VS Code, or Laravel Herd or Sail, with permission to install software
Curriculum
Course Details
This course is the 2026 edition of Laravel Advanced. It runs for 5 days, 6 hours per day (30 hours in total, 09:00-16:00), as lectures with labs and a workshop. Advanced level. This edition moves from Laravel 5 to Laravel 13 on PHP 8.5, using PHP attributes for jobs and controllers, Queue::route and Pest, and adds browser testing with the Pest Browser Plugin alongside Laravel Dusk, architecture tests, Larastan and
CI with GitHub Actions. It keeps the core topics of queues with Horizon, events, package development, repositories, design patterns, SOLID and TDD. Building an app with Vue.js has been removed because it is covered in Laravel with Vue.js Workshop. The course builds on Basic Laravel for Beginners. Learners use their own GitHub account for Socialite and GitHub Actions, and take home a lab guide, tested source code for every lab and their capstone project.
Day 1 Inside Laravel 13 and Advanced Eloquent
Section 1: Lab: Setting Up a Team-Ready Laravel 13 Project
- What is new in Laravel 13, and upgrading from earlier versions
- Development environments with Laravel Herd or Sail (Docker)
- Code formatting with Pint and static analysis with Larastan
- Customising stubs and creating your own make commands
- Lab: a starter project used throughout the course
Section 2: The Service Container, Providers and Facades
- Dependency injection and autowiring in Laravel
- Bindings, singletons and contextual binding
- When to use app()->make(), and when not to
- Service providers and creating your own facade
- Lab: swap SMS providers behind an interface
Section 3: Advanced Routing and Controllers
- Route model binding with custom keys and scoped bindings
- Controller attributes such as #[Middleware] and #[Authorize]
- Single action controllers and keeping controllers tidy
- Form requests for advanced validation and authorisation
- Lab: refactor an overgrown controller
Section 4: Lab: Advanced Eloquent
- Polymorphic relationships for comments and favourites
- Value objects with Eloquent through custom casts
- Query scopes and eager loading to prevent N+1 queries
- Model factories for realistic test data
- Lab: a favourites system
Day 2 Queues, Events and Background Work
Section 5: Lab: Queues with Redis
- Jobs, dispatching and choosing a connection
- Controlling behaviour with #[Tries], #[Backoff] and #[Timeout]
- Routing jobs to queues with Queue::route
- Job chaining, batching and unique jobs
- Lab: send bulk notifications through a queue
Section 6: Laravel Horizon and Supervisor
- Install Horizon and read its dashboard
- Set worker counts and balancing in config/horizon.php
- Failed jobs, retries and alerts when a queue backs up
- Keep the Horizon process running on a server with Supervisor
- Lab: tune queues for urgent and heavy jobs
Section 7: Events, Listeners and Notifications
- Synchronous and queued events and listeners
- Domain events to separate side effects from business logic
- Observers versus events, and their pitfalls
- Notifications over several channels, including email and database
- Lab: notify users when a payment succeeds
Section 8: Lab: Artisan Commands and Task Scheduling
- Create Artisan commands with arguments and options
- Schedule tasks and prevent overlapping runs
- Recurring work such as daily totals and clearing old data
- Lab: a sales summary emailed every morning
Day 3 SOLID, Design Patterns and Extra Services
Section 9: SOLID Principles in a Laravel Project
- SRP and OCP with code that keeps growing
- LSP and ISP through small, clear interfaces
- DIP together with the service container
- How small objects make code easier to test and change
- Lab: refactor pricing code following SOLID
Section 10: Lab: Repositories, Services and Action Classes
- Simple repositories, and when you do not need one
- Reusing shared methods across repositories
- Services and action classes for business logic
- DTOs for passing typed data between layers
- Lab: a payment history page with clearly separated layers
Section 11: Design Patterns Common in Laravel
- Decorator for adding caching to a repository
- Chain of Responsibility through pipelines and middleware
- Strategy for swapping calculations or payment channels
- View presenters for formatting data before display
- Lab: multi-rule discounts with a pipeline
Section 12: Lab: Search with Scout and Login with Socialite
- Search data with Laravel Scout using the database engine
- An overview of external engines such as Meilisearch and Typesense
- Log in with a GitHub account through Laravel Socialite
- Lab: a product search page and GitHub login
Day 4 Testing and TDD
Section 13: Lab: Testing Basics with Pest
- Unit and feature tests in Laravel
- RefreshDatabase and model factories
- Pest datasets and expectations
- Lab: test the favourites system built earlier
Section 14: Mocks, Fakes and Integration Tests
- Test email sending with Mail::fake()
- Queue::fake(), Event::fake() and Notification::fake()
- Simulate external APIs with Http::fake()
- Mocking, and the risks of mocking too much
- Lab: an integration test of the payment flow
Section 15: Lab: TDD Through a Real Example
- The red, green and refactor cycle
- Write the test first, then build the feature step by step
- Refactor Laravel code with tests to back it
- Lab: build a user profile page with TDD
Section 16: Browser Tests and Architecture Tests
- Browser tests with the Pest Browser Plugin, which runs on Playwright
- Laravel Dusk for existing projects that already use it
- Architecture tests to enforce rules about code structure
- Lab: a browser test of sign-up and login
Day 5 Packages, CI/CD and Capstone
Section 17: Lab: Developing Your Own Package
- Extract reusable code into a package
- Package structure, service providers and package discovery
- Publishing a package's config, migrations and views
- Lab: a package that records data change history
Section 18: Good Practice in Package Development
- Test a package with Orchestra Testbench
- Semantic versioning and keeping compatibility
- Publish on Packagist or use a private repository
- Write a README and changelog the team can rely on
Section 19: Lab: CI/CD with GitHub Actions
- A workflow that runs Pint, Larastan and Pest on every pull request
- Managing secrets and .env files for each environment
- Deployment steps and restarting workers with horizon:terminate
- Lab: a pipeline that blocks merging when tests fail
Section 20: Workshop: Capstone Membership and Payment System
- Design the feature with action classes, events and queues
- Write tests with TDD and browser tests for the main flows
- Use an AI assistant to review the code, then check every point yourself
- Present the work and review the design together
Schedule & training options
For individuals — public rounds
No public rounds are open right now. Join the waiting list and we will contact you first when the next round opens, or ask us on LINE. Or call 02-570-8449 or 088-807-9770
For organisations — in-house / private
- Tailor the content to your team’s tools and projects
- Your dates, at your office or live online
- Quotation with tax ID for procurement
Instructors
Frequently asked questions
What is Laravel Horizon, and how is it different from running queue:work yourself?
Laravel Horizon is a package for managing Redis-backed queues, with a dashboard showing waiting jobs, throughput, run times and failed jobs. You define the number of workers and how they are balanced across queues in config/horizon.php instead of starting several queue:work processes by hand. On a production server Horizon is usually kept running by Supervisor, and you run horizon:terminate on every deployment so workers load the new code.
What are the steps of test-driven development (TDD)?
TDD works in short cycles of three steps. First write a test describing the behaviour you want and watch it fail (red), then write the least code needed to make it pass (green), and finally tidy the code while the tests confirm nothing has changed (refactor). You repeat the cycle feature by feature. This course practises TDD through real examples with Pest and refactoring Laravel code under test.
What are the SOLID principles, and how do they improve Laravel code?
SOLID is five object-oriented design principles: single responsibility (one job per class), open/closed (extend without editing existing code), Liskov substitution (subclasses must stand in for their parents), interface segregation (small, focused interfaces) and dependency inversion (depend on interfaces, not concrete classes). Following them makes code easier to change and test. In Laravel, dependency inversion pairs naturally with the service container, which injects dependencies for you.
Should browser tests in Laravel use Laravel Dusk or Pest?
Both can test your app through a real browser. Laravel Dusk has been used for years and still suits projects that already have Dusk tests. The Pest Browser Plugin runs on Playwright, uses the same style as your other Pest tests, works with Laravel's testing helpers and can test several browsers and screen sizes. New projects already on Pest usually start with Pest. This course covers both and compares them.
Who is the Laravel Advanced course for, and what should I know beforehand?
It suits web developers who use Laravel at work, programmers looking after large Laravel systems, in-house IT teams and tech leads who set code standards. You should have completed a basic Laravel course or be able to build a site with routes, controllers, Blade and Eloquent, understand object-oriented PHP and be comfortable with Git and Composer, because the course does not revisit the basics.
Can the Laravel Advanced course be run in-house for our team?
Yes. It can be run in-house for your team, with examples adapted to your work, such as refactoring your existing Laravel code with tests or shaping a GitHub Actions pipeline around your team's process. You can request a quotation from this page, or contact us on LINE @itgenius or by phone on 02-570-8449.
Related articles
Articles are published in Thai.