Be part of JetBrains PHPverse 2026 on June 9 – a free online event bringing PHP devs worldwide together.

Browse all series

Modular Laravel

In this course, we'll discuss the modular monolith, or - if you want to sound fancy - a module-oriented architecture. A modular monolith provides a fantastic middle-ground between the simplicity of a traditional monolithic architecture, and some of the benefits you might encounter within a microservice-based architecture. Curious to learn more? Let's get going!

Progress

Series Info

Episodes
25
Run Time
3h 31m
Difficulty
Advanced
Last Updated
Jan 4, 2024
Version
Latest
Play Series

Series Episodes

  1. Episodes (25)

    1. Introduction

      Let's begin by discussing what we're going to build, as well as the particular challenges we want to tackle along the way.

    2. Splitting the Application

      Let's learn how to logically divide our application into different modules.

    3. Setting Up Service Providers

      In this episode, you will learn how to set up service providers for each of your modules.

    4. Where to Put Automated Tests

      If we have different modules, where do we store the tests? In the usual place? Inside each module? Let's figure that out.

    5. Setting Up Model Factories

      Let's explore some potential options for where to store our model factories.

    6. Install the IDE Helper

      The Laravel IDE Helper is a fantastic package. Let's learn how to configure it to work with modules.

    7. Building a Basic Checkout Flow

      Let's start by constructing the most basic version of a checkout.

    8. Introducing Data Transfer Objects

      Let's learn how we can use DTOs to pass data around different modules in our application.

    9. Introducing a Payment Model

      Let's add a Payment abstraction to make our application more complete.

    10. Extracting Behavior to Actions

      Moving on, let's see how we might use actions (self-handling commands) to encapsulate and orchestrate behavior in our application.

    11. Payment Actions and Database Transactions

      Let's extract payment logic into a separate class and introduce database transactions.

    12. Encapsulating Behavior Into Models

      Let's learn how to make our models a little bit richer by encapsulating important behavior.

    13. Temporal Coupling and Events

      Let's next review what problems temporal coupling introduces, and how we can leverage an event system to deal with it.

    14. Consolidating Data Into Dtos

      Let's see how we can use DTOs to consolidate data and enable stable contracts.

    15. Where We Are

      Let's take a quick break and see what we have started with and what we currently have built.

    16. Introducing Interfaces and Enabling Polymorphism

      Let's learn how we can use interfaces at the entry-points of our modules to enable polymorphism.

    17. Automatically Loading Views and Components

      Laravel doesn't know where to look for views and components within a custom directory structure. Let's figure out how to configure that.

    18. Tooling

      The Laravel ecosystem provides many tools to help us build modular applications. Let's review a handful of them together in this episode.

    19. Vertical Slices

      Let's see what vertical slices are and how we can implement them in an application.

    20. Grouping by Type

      The standard way to build Laravel applications is by grouping components by type. Let's see how to implement that within modules.

    21. How to Fake Boundaries

      Let's learn how to replace different components that interact with our modules by fake versions in our tests.

    22. Applying Templates to Our Mailables

      As we've been working, some mistakes were understandably made. Let's fix our mailables to load Blade templates.

    23. An Event-driven Approach - Part 1

      Let's learn how to re-architect our checkout to use events, and what differences that would make in our application.

    24. An Event-driven Approach - Part 2

      In this lesson, we'll review a simple implementation of an event-driven approach.

    25. Wrapping Up

      It's time for us to say goodbye. If you've made it this far, thanks so much for coming along. I hope you got a lot out of this course.

Continue Learning

Frontend Mentor Challenge with Laravel thumbnail

Frontend Mentor Challenge with Laravel

With Simon Vrachliotis

In this series, we take a Frontend Mentor challenge and build it using Laravel and Tailwind CSS. Rather than chasing pixel-perfect replication, the focus is on pragmatic Laravel and backend logic. Along the way, we explore carts, session state, semantic markup, and UI polish.

  • 27 Episodes
Debugging Real-World Production Nightmares thumbnail

Debugging Real-World Production Nightmares

With Jeremy McPeak

Production bugs don't announce themselves politely. In this series, we confront ten nightmare scenarios using NightmareMart, an intentionally broken e-commerce app, demonstrating how to debug calmly and methodically when everything is on fire.

  • 10 Episodes
Motion For The Web thumbnail

Motion For The Web

With Simon Vrachliotis

Master the art of modern web animation, from subtle CSS transitions to full-blown JavaScript motion systems. This series starts with the fundamentals of smooth, accessible CSS motion, then builds through keyframes, scroll-linked animations, SVG techniques, and the Web Animations API, finishing with powerhouse libraries like Motion.dev, AnimeJS, and GSAP.

  • 43 Episodes
How to Build a Dev Team thumbnail

How to Build a Dev Team

With Matt Stauffer

Resources for learning to code are everywhere. The only hard part is choosing one. But when it comes to learning how to lead a development team, quality resources are incredibly scarce. This course fills that gap. It contains all of the lessons I learned while building the dev team at Tighten, a Laravel consultancy known for producing great work, but with an even better reputation as a fantastic place to work.

  • 12 Episodes
BaseCode Reloaded thumbnail

BaseCode Reloaded

With Jason McCreary

Years and years of hard-fought coding breakthroughs, distilled into sixteen essential lessons.In this course, I'll show you how to write code for humans, not just machines. Together, we’ll review powerful techniques, like naming, structuring, removing clutter, and spotting patterns. These aren’t abstract theories from a dusty book. They’re practical and proven habits that you can apply to your codebase right now. If you’ve ever opened an old file and struggled to understand your own code, this course was made just for you.

  • 16 Episodes