Mail templates in Laravel - Step-by-Step Execution

Concept Flow - Mail templates

Create Mailable Class

↓

Define build() method

↓

Select Mail Template View

↓

Pass Data to View

↓

Send Mail Using Mailable

↓

Mail Rendered with Template and Data

This flow shows how Laravel uses a Mailable class to select a mail template, pass data, and send the email.

Execution Sample

Laravel

class OrderShipped extends Mailable {
  public $order;

  public function __construct($order) {
    $this->order = $order;
  }

  public function build() {
    return $this->view('emails.shipped')
                ->with(['order' => $this->order]);
  }
}

Mail::to($user)->send(new OrderShipped($order));

This code creates a mail template class that uses a Blade view and sends it to a user with order data.

Execution Table

Step	Action	Evaluation	Result
1	Create OrderShipped Mailable instance	new OrderShipped($order)	Instance with order data stored
2	Call build() method	return view('emails.shipped') with order data	Selects Blade template and attaches data
3	Call Mail::to($user)->send()	Send email using Mailable	Email queued for sending with rendered template
4	Render Blade template	Replace {{order}} placeholders	Final email content with order details
5	Email sent to user	User receives email	User sees formatted email with order info

💡 Email sent successfully with the selected template and data.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
order	undefined	Order object passed	Passed to view data	Used in email content	Remains unchanged
mailable	undefined	Instance created	build() returns view with data	Used to send email	Instance used for rendering
email_content	undefined	undefined	Rendered with order data	Sent to user	Delivered email content

Key Moments - 3 Insights

Why do we use a Mailable class instead of sending raw HTML directly?

The Mailable class organizes email logic and templates clearly. As shown in step 1 and 2 of the execution_table, it helps pass data and select templates cleanly.

How does the Blade template get the order data?

In step 2, the build() method attaches the order data with ->with(['order' => $this->order]). This makes the data available inside the Blade view.

When is the email content actually rendered?

Step 4 shows the Blade template rendering happens just before sending, replacing placeholders with real data.

Visual Quiz - 3 Questions

Look at the execution_table, what happens at Step 2?

A The Mailable instance is created

B The email is sent to the user

C The build() method selects the mail template and attaches data

D The Blade template is rendered

💡 Hint

Check the 'Action' and 'Result' columns at Step 2 in the execution_table

At which step is the email content rendered with order details?

A Step 3

B Step 4

C Step 1

D Step 5

💡 Hint

Look for 'Render Blade template' in the 'Action' column of execution_table

If we do not pass order data in build(), what changes in variable_tracker?

A email_content renders without order data

B order remains undefined in all steps

C order is passed but empty

D mailable instance is not created

💡 Hint

Check the 'order' row in variable_tracker and consider what happens if data is not passed

Concept Snapshot

Laravel Mail Templates:
- Create a Mailable class with build() method
- Use ->view('template') to select Blade template
- Pass data with ->with([...])
- Send mail with Mail::to()->send(new Mailable)
- Blade renders template with data before sending

Full Transcript

In Laravel, mail templates are managed by creating a Mailable class. This class has a build() method where you select a Blade template and pass data to it. When you send the mail using Mail::to()->send(), Laravel renders the Blade template with the data and sends the email. The process starts by creating the Mailable instance with data, then selecting the template, rendering it with data, and finally sending the email to the user. This organized flow helps keep email logic clean and reusable.