Magento 2 Mastery

HTTP Methods: GET, POST, PUT, DELETE and More

Comprehensive guide to HTTP methods including GET, POST, PUT, DELETE, PATCH, OPTIONS, and HEAD with practical PHP examples.

HTTP Status Codes: Complete Reference

Master HTTP status codes across all categories (2xx, 3xx, 4xx, 5xx) with Magento-specific usage examples.

HTTP Headers: Working with Request and Response Headers

Master HTTP headers including Content-Type, Authorization, Cache-Control, CORS, and custom headers with PHP header() function examples.

Cookies and Sessions: State Management on the Web

Understand cookies vs sessions, PHP session handling, cookie security, SameSite attributes, and how Magento manages sessions.

HTML5 Semantic Elements, Forms, and Accessibility

Master HTML5 semantic elements, form handling, validation, accessibility basics, and how HTML is used in Magento templates.

CSS Selectors, Box Model, Flexbox, and Responsive Design

Master CSS fundamentals including selectors, box model, flexbox, grid, responsive design, and how CSS works in Magento's LESS compilation.

JavaScript ES6+ Features and DOM Manipulation

Master modern JavaScript (ES6+) features, DOM manipulation, fetch API, modules, async/await, and JavaScript in the Magento context.

PHP Variables: Syntax, Scoping, and Superglobals

Master PHP variable syntax, scoping rules, superglobals, type juggling, null coalescing operator, and practical examples.

PHP Data Types: Scalar, Compound, and Special Types

Comprehensive guide to PHP data types including scalar types, compound types, special types, type casting, and strict types declaration.

PHP Arrays: Indexed, Associative, and Essential Functions

Master PHP arrays including indexed and associative arrays, and essential array functions (map, filter, reduce, array_column, array_merge) used heavily in Magento.

PHP Functions: Declaration, Arguments, and Return Types

Master PHP functions including declaration, arguments, return types, variadic functions, and named arguments in PHP 8.

PHP Classes: Properties, Methods, and Constructors

Master PHP classes including declaration, properties, methods, constructors, visibility (public/private/protected), and static methods.

PHP Interfaces: Contracts and Dependency Injection

Master PHP interfaces, interface contracts, multiple interface implementation, and why interfaces matter for dependency injection in Magento.

Abstract Classes: Shared Implementation and Templates

Master abstract classes, abstract methods, when to use abstract vs interface, and how Magento uses both extensively.

PHP Inheritance: Single Inheritance and Method Overriding

Master PHP inheritance, method overriding, parent:: calls, Liskov Substitution Principle, and Magento's class hierarchy.

PHP Traits: Code Reuse Without Inheritance

Master PHP traits, trait conflicts, trait vs inheritance, and how Magento uses traits for code reuse (e.g., Subject.php traits).

PSR-4 Namespaces and Autoloading in PHP

Master PSR-4 namespaces, use statements, namespace resolution, and Magento's Vendor\Module namespace convention.

PHP Exceptions: Error Handling and Custom Exceptions

Master try/catch/finally, exception hierarchy, custom exceptions, SPL exceptions, and Magento exception types.

PHP Type Declarations: Scalar Types, Union Types, and Constructor Promotion

Master scalar type hints, return types, union types (PHP 8.0), named arguments, and constructor promotion.

PHP Closures: Anonymous Functions and Callback Patterns

Master anonymous functions, closures, the use keyword, Closure::bind, and callback patterns used in Magento plugins.

Composer: PHP Package Management

Master composer.json, composer.lock, install/update/require, repositories, scripts, and Magento's composer.json.

PHP Autoloading: PSR-4 and Magento's Mechanism

Master PSR-4 autoloading, spl_autoload_register, Composer autoloader, and Magento's autoloading mechanism.

PSR Standards: Why Standards Matter in PHP

Overview of PSR standards, why they matter, and how Magento follows PSR-1, PSR-4, PSR-12, and PSR-7.

PSR-4 Autoloading Standard in Detail

Deep dive into PSR-4 autoloading standard, directory mapping, namespace to path conversion, and Magento's autoload.php.

PSR-12 Extended Coding Style Guide

Master the PSR-12 coding style guide including indentation, namespace order, class/method spacing, visibility, and Magento code style.

Git Basics and Version Control for Magento

Master Git basics, branching, merging, rebasing, git flow for Magento modules, and commit conventions.

PHPUnit: Testing PHP and Magento Applications

Master PHPUnit basics, test cases, assertions, data providers, mocking, and Magento testing patterns.

SOLID & Design Principles - OOP Fundamentals

The four pillars of Object-Oriented Programming in PHP: encapsulation, abstraction, inheritance, and polymorphism with real-world Magento examples

SOLID Design Principles

Deep dive into all five SOLID principles with PHP code examples showing violations and correct implementations

DRY, KISS & YAGNI Principles

Understanding when to apply and when to avoid DRY, KISS, and YAGNI principles in PHP and Magento development

Encapsulation vs Abstraction Deep Dive

Detailed exploration of encapsulation and abstraction, access modifiers, information hiding, public API design, and Magento service contracts

Composition vs Inheritance

When to use composition over inheritance, dependency injection as composition, and Magento's preference for composition

Dependency Injection

What dependency injection is, constructor/setter/interface injection, benefits, and why Magento uses DI heavily

Dependency Inversion Principle

DIP explained - depending on abstractions not concretions, enabling testing and flexibility in Magento applications

Factory Pattern

Factory, Abstract Factory, and Simple Factory patterns with PHP examples and Magento's Factory classes

Repository Pattern

Repository pattern for data access abstraction, CRUD operations, search criteria, and Magento's Repository implementations

Service Layer Pattern

Service Layer pattern for business logic encapsulation and how Magento service contracts implement this pattern

Strategy Pattern

Strategy pattern for defining families of algorithms and selecting them at runtime, with Magento shipping and payment examples

Adapter Pattern

Adapter pattern for converting interfaces, with Magento payment gateway and shipping carrier adapter examples

Decorator Pattern

Decorator pattern for adding behavior dynamically, with Magento pricing and totals decorator examples

Proxy Pattern

Proxy pattern for lazy loading, access control, and logging, with Magento proxy classes for performance

Observer Pattern

Observer pattern for event-driven architecture, Magento events and observers, and when to use observers vs plugins

Command Pattern

Command pattern for encapsulating requests, Magento console commands, and action controllers as commands

Exception Design Patterns

Exception hierarchy design, custom exception chains, exception vs error codes, and Magento exception patterns

PSR-3 Logging & Magento Logging

PSR-3 logging standard, log levels, structured logging, and Magento's logging system

PHP Security Fundamentals

SQL injection, XSS, CSRF, file inclusion, session hijacking, PHP security functions, and Magento security measures

PHP Performance Optimization

OPcache, memory management, profiling, Xdebug impact, PHP-FPM tuning, and performance considerations for Magento

PHPUnit Unit Testing

PHPUnit test structure, assertions, data providers, setUp/tearDown, and writing tests for PHP classes

Mock Objects & Test Doubles

Mock objects, stubs, test doubles, Mockery/PHPUnit mocking, and testing with dependencies

Static Analysis Fundamentals

Static analysis vs dynamic analysis, benefits for catching bugs early, PHPStan, Psalm, and PHPMD

PHPStan Configuration & Rules

PHPStan configuration, levels, rules, extensions, and Magento PHPStan setup and rules

PHP CodeSniffer & Magento Coding Standards

PHP CodeSniffer, sniff rules, custom standards, and Magento coding standards (Magento2 coding standard)

What is Magento 2?

What Magento 2 is - open source e-commerce platform, PHP-based, owned by Adobe. History, market position, why learn Magento

Magento Ecosystem

Magento ecosystem - agencies, extension marketplace, community, certifications, and job market

Magento Open Source

Magento Open Source (formerly Community Edition) - features, limitations, what's included vs Adobe Commerce

Adobe Commerce

Adobe Commerce (formerly Magento Commerce/Enterprise) - additional features, B2B, cloud, pricing model

Magento 2 Architecture Overview

High-level Magento architecture - modular design, service contracts, areas, themes, and architecture diagram description

Magento Directory Structure

Magento directory structure overview - app/, vendor/, pub/, var/, generated/. What each directory contains

Magento Bootstrap Process

Magento bootstrap process - index.php, ObjectManager initialization, area code setup, configuration loading

Magento Entry Points

Different entry points - pub/index.php (frontend), pub/admin.php (admin), rest/V1 (API), crontab (cron). How each routes differently

Complete Request Lifecycle

Complete request lifecycle from HTTP request to response. Bootstrap → Area Code → Router → Controller → Action → Response

Front Controller Pattern

Front controller pattern in Magento. Magento\Framework\App\FrontController, how it dispatches to action controllers

Magento 2 Routing & Areas

How Magento routing works, route IDs, front names, and router class matching.

Magento 2 Router Classes

Deep dive into Magento router classes - Standard, UrlRewrite, Router interface, custom routers, and priority matching.

Magento 2 Areas Concept

Understanding Magento area concept - global, frontend, adminhtml, webapi_rest, webapi_graphql, crontab and how areas affect configuration loading.

Magento 2 Global Area

Understanding the global area - shared configuration, DI compilation, and how it relates to other areas.

Magento 2 Frontend Area

Frontend area specifics - layout handles, themes, blocks, templates, and JavaScript components.

Magento 2 Adminhtml Area

Adminhtml area specifics - admin routes, ACL, UI components, admin themes, and system configuration.

Magento 2 Web API Area

Web API area - REST routes, GraphQL, service contracts exposed via API, and webapi.xml configuration.

Magento 2 Cron Area

Cron area specifics - cron groups, scheduled tasks, cron configuration, and the Magento cron runner.

Magento 2 Modules

What Magento modules are, module lifecycle, enabling/disabling, dependencies, and module list.

Magento 2 Themes

Theme hierarchy, parent/child themes, theme inheritance, theme configuration, and custom themes.

Magento 2 Internal Libraries

Magento internal libraries - Framework, modules, vendor packages, and how libraries are organized.

Magento 2 Generated Code

Generated code - generated/ directory, factories, proxies, interceptors, and auto-generated classes.

Magento 2 Cache and Session Handling

Cache types, Redis, sessions, and how Magento caches configuration and layout.

Magento 2 Events and Observers

Event system - dispatching events, creating observers, events.xml, and observer execution.

Magento 2 Plugins (Interceptors)

Before/after/around plugins, plugin configuration, ordering, and limitations.

Magento 2 Preferences

Interface to class mapping, when preferences are used, and conflicts between preferences.

Magento 2 Dependency Injection

DI decision framework: when to use constructor injection, factories, proxies, and virtual types. Includes common patterns, anti-patterns, and troubleshooting.

Magento 2 ObjectManager

What ObjectManager does, why direct usage is discouraged, and how it works under the hood.

Magento 2 Directory Structure

Complete Magento directory structure - app/code, app/design, vendor, pub, var, generated, dev, bin, setup.

Magento 2 app/ Directory

Deep dive into app/code, app/design, app/etc, and app/i18n directories.

Magento 2 vendor/ Directory

Composer packages, vendor/magento core, vendor packages, and autoload files.

Magento 2 registration.php

ComponentRegistrar, module registration, and how Magento discovers modules.

Magento 2 module.xml

Module declaration, sequence dependencies, setup_version, and component type.

Magento 2 di.xml

Global and area-specific di.xml, type configuration, preferences, virtual types, arguments, and plugin declarations.

Magento 2 Complete Module Architecture

All files in a module, their purposes, how they connect, and complete module directory tree.

routes.xml - Module Configuration Files

Understanding Magento 2 routes.xml configuration: route IDs, front names, module mapping, and how routes connect URLs to controllers

events.xml - Module Configuration Files

Understanding Magento 2 events.xml: event names, observer configuration, observer classes, and the disabled flag for event-driven architecture

webapi.xml - Module Configuration Files

Understanding Magento 2 webapi.xml: REST routes, SOAP services, method definitions, service classes, and ACL resource authorization

system.xml - Module Configuration Files

Understanding Magento 2 system.xml: system configuration fields, groups, sections, field types, and admin configuration panels

Controller Directory - Module Directories Deep Dive

Understanding the Magento 2 Controller directory: Action classes, ResultFactory, forwards, redirects, and controller action patterns

Model Directory - Module Directories Deep Dive

Understanding the Magento 2 Model directory: data models, resource models, interfaces, and the data/resource/model architecture

Block Directory - Module Directories Deep Dive

Understanding the Magento 2 Block directory: block classes, template rendering, cache keys, cache lifetimes, and layout integration

View Directory - Module Directories Deep Dive

Understanding the Magento 2 View directory: frontend layout, templates, web assets, adminhtml structure, and area-specific organization

Step-by-Step Creating a Magento Module

Complete guide to creating a Magento 2 module from scratch: registration.php, module.xml, directory structure, and initial configuration

Enabling a Magento Module

Step-by-step guide to enabling a Magento 2 module: bin/magento commands, cache clearing, and verification with module:status

Setting Up Routes in a Module

Practical guide to configuring routes.xml, setting front names, creating controllers, and testing routes in Magento 2

Creating Controller Actions

Practical guide to creating Magento 2 controller actions: IndexAction, ResultFactory usage, page/JSON/redirect results, and form handling

Creating Blocks and Templates

Practical guide to creating Magento 2 block classes and .phtml templates: data passing, variable output, escaping, and template inheritance

Layout XML - Complete Guide

Understanding Magento 2 Layout XML: handles, blocks, containers, references, arguments, and complete layout configuration examples

ViewModel Pattern - Separating Logic from Blocks

Understanding the Magento 2 ViewModel pattern: separating business logic from blocks, DI in view models, and writing clean template code

Adding CSS and JS to Modules

Guide to adding CSS, Less, JavaScript, and mixins to Magento 2 modules: requirejs-config.js, Less compilation, JS components, and asset deployment

Setting Up Dependency Injection

Guide to Magento 2 Dependency Injection: constructor injection, di.xml configuration, interface bindings, and DI best practices

Resource Models - Database Operations

Guide to Magento 2 resource models: extending AbstractDb, CRUD operations, table definitions, and data types for database interactions

Creating Repositories - Service Contracts

Guide to Magento 2 repositories: RepositoryInterface, SearchResults, SearchCriteria interface, and implementing the service contract pattern

Admin System Configuration

Guide to Magento 2 admin configuration: system.xml, adminhtml menu, config fields, backend models, and configuration scopes

Creating Database Tables

Guide to Magento 2 database tables: db_schema.xml, column types, indexes, constraints, and data patches for declarative schema

Setting Up API - Complete Guide

Guide to setting up Magento 2 API: webapi.xml, service contract interfaces, ACL resources, and creating custom REST API endpoints

Testing Magento Modules

Guide to testing Magento 2 modules: unit tests, integration tests, test fixtures, test configuration, and writing effective tests

Deploying Modules to Production

Guide to deploying Magento 2 modules to production: static content deployment, cache management, indexer management, and production checklist

Constructor Injection in Detail

Deep dive into Magento 2 constructor injection: PHP 8 constructor promotion, required vs optional parameters, DI resolution, and best practices

ObjectManager Deep Dive

Understanding Magento 2 ObjectManager internals: how it creates objects, shared instances, auto-wiring, configuration merging, and when to use it

di.xml Deep Dive

Comprehensive guide to Magento 2 di.xml: type arguments, init_arguments, shared flag, cleanup, area-specific DI, and advanced configurations

Preferences Deep Dive

Advanced guide to Magento 2 preferences: global vs area preferences, preference conflicts, when to use preferences vs plugins, and best practices

Virtual Types - Advanced DI

Understanding Magento 2 virtual types: creating anonymous class configurations, aliasing, use cases for testing and customization

Magento Factories - Object Creation

Understanding Magento 2 factories: ObjectManager factory creation, generated factory classes, when to use factories, and factory patterns

Magento Proxies - Lazy Loading

Understanding Magento 2 proxies: lazy loading, proxy generation, performance optimization, and when proxies help performance

Shared vs Non-Shared Objects

Understanding Magento 2 shared vs non-shared objects: singleton behavior, state management, and configuration patterns

DI Arguments in di.xml

Passing configuration values through dependency injection using string, int, boolean, object, array, const, and null argument types.

DI Compilation

The setup:di:compile command, generated classes, optimization, and when to recompile.

Generated Code for DI

Understanding factories, proxies, interceptors (plugins), and the generated classes directory.

Circular Dependencies

Detection, common causes, solutions, and Magento error messages for circular dependency issues.

module.xml Deep Dive

Advanced module.xml configuration including sequence dependencies, setup scripts, component_type, and disabled flag.

di.xml Deep Dive

Comprehensive guide to Magento 2 di.xml: type arguments, init_arguments, shared flag, cleanup, area-specific DI, and advanced configurations

routes.xml Deep Dive

Multiple routes, router class overrides, route priority, and advanced routing configuration.

events.xml Deep Dive

Area-specific observers, disabled observers, shared observers, and advanced event configuration.

webapi.xml Deep Dive

REST resource paths, method mapping, ACL resources, and SOAP vs REST configuration.

acl.xml — ACL Resource Tree

ACL resource tree definitions, admin permissions, role management, and access control configuration.

system.xml Deep Dive

Sections, groups, fields, field types (text, boolean, select, multiselect, image), and backend models.

config.xml — Default Configuration Values

Default config values, config types, config scopes, and how config.xml interacts with core_config_data.

crontab.xml — Cron Job Declarations

Cron job declarations, job classes, schedules using cron expressions, and cron group management.

menu.xml — Admin Menu Structure

Admin menu items, ACL permissions, custom menu entries, and menu configuration.

indexer.xml — Indexer Declarations

Indexer declarations, indexer classes, data providers, and view management in Magento.

How Magento Merges XML

Merge order, area-specific overrides, debugging merge conflicts, and XML configuration resolution.

Routes Deep Dive

Route matching, custom routers, URL rewrite integration, and advanced routing patterns.

Controllers Deep Dive

AbstractAction, ActionInterface, HTTP vs non-action controllers, and controller architecture.

Action Patterns

GET/POST handlers, form validation, error handling, and message patterns in controllers.

Magento Request/Response

Request object, Response object, headers, cookies, HTTP status codes, and request handling.

ResultFactory — Creating Results

Creating page, JSON, redirect, and raw result objects using ResultFactory.

PageFactory — Creating CMS Pages

Creating CMS pages, layout handles, page configuration, and dynamic page generation.

Redirect Patterns

redirectBack, redirect to URL, redirect with messages, cookies, and redirect best practices.

Complete Request Lifecycle Deep Dive

Every step from HTTP request to response — bootstrap, routing, controller, action, result, and response.

Magento Models

ExtensibleObject, data interfaces, model loading, save/delete, and model architecture.

Resource Models

AbstractDb, table definition, CRUD operations, afterSave/afterLoad, and resource model architecture.

Collections

AbstractCollection, filtering, sorting, loading, performance considerations, and collection patterns.

Repositories & SearchCriteria

CRUD via repositories, SearchCriteria, search results, and extension attributes.

Service Contracts

API interfaces, data interfaces, repository interfaces, and why they matter for Magento development.

Magento Interfaces

Product interface, order interface, customer interface, and creating custom interfaces.

Data Interfaces

Get/set methods, immutable vs mutable interfaces, extension attributes, and data interface patterns.

SearchCriteria

FilterGroup, Filter, SortOrder, pagination, and building complex queries with SearchCriteria.

MySQL in Magento

MySQL configuration for Magento including InnoDB engine, character sets, collation, and optimal settings

EAV Concept Introduction

Introduction to Entity-Attribute-Value model, why Magento uses EAV, and how EAV tables are structured

Flat Tables in Magento

Understanding flat tables, catalog_product_flat, catalog_category_flat, and when they help performance

Magento Entity Tables

Core entity tables in Magento: catalog_product_entity, catalog_category_entity, customer_entity, sales_order

EAV Attribute Tables

EAV attribute tables including eav_attribute, eav_entity_type, attribute options, and source models

Index Tables in Magento

Index tables for products and categories, their structure, and how indexing improves performance

URL Rewrite System

URL rewrite system including url_rewrite table, product and category URLs, custom rewrites, and redirects

Declarative Schema

Declarative schema approach with db_schema.xml, columns, indexes, constraints, and table definitions

Data Patches

Data patches in Magento 2 using DataPatchInterface for data installation, migration, and rollback

Schema Patches

Schema patches using SchemaPatchInterface for database structure modifications and migrations

Database Migration

Magento database migration using Data Migration Tool, migration scripts, and version upgrades

MySQL Query Optimization

MySQL query optimization for Magento including EXPLAIN, slow query log, indexing strategy, and query patterns

EAV Entities

EAV entity types including product, category, customer, order, entity IDs, and entity management

EAV Attributes

EAV attribute properties, attribute codes, backend type, frontend input, and validation

EAV Values

EAV value tables including varchar, int, decimal, text, datetime, value storage, and retrieval

EAV Backend Types

EAV backend types including text, varchar, int, decimal, datetime, static, and when to use each

EAV Source Models

EAV source models for select attributes, option values, custom source models, and option arrays

Attribute Sets

Attribute sets including default set, custom sets, attribute groups, and assigning attributes to sets

Creating Custom EAV Attributes

Creating custom EAV attributes with install data scripts, attribute creation, source models, and frontend models

EAV Performance

EAV performance optimization including joins vs flat tables, collection loading, attribute loading, and indexing impact

Simple Products

Simple products including basic product type, SKU, inventory, pricing, and associations

Configurable Products

Configurable products including configurable attributes, variations, pricing, and stock management

Grouped and Bundle Products

Grouped products and bundle products including options, pricing, inventory, and use cases

Virtual and Downloadable Products

Virtual and downloadable products including digital goods, links, samples, and license management

Categories

Category tree structure, URL keys, display modes, anchor categories, and category attributes

Catalog Attributes and Sets

Catalog attribute types, attribute options, attribute validation, and attribute management

Catalog Collections

ProductCollection, CategoryCollection, filtering, joins, and performance optimization

Magento Pricing

Magento pricing including base price, special price, tier price, group price, and price indices

Tier Pricing

Tier pricing including quantity breaks, customer group pricing, and tier price calculation

Multi-Source Inventory (MSI)

Multi-Source Inventory including sources, stocks, reservations, salable quantity, and inventory APIs

Catalog Search

Catalog search including search engine integration, search criteria, relevance, and search configuration

URL Rewrite System

URL rewrite system including url_rewrite table, product and category URLs, custom rewrites, and redirects

Cart and Quote System

Understanding Magento's Cart and Quote system - Quote model, Quote items, cart persistence, and quote management

Quote Items

Working with Quote items - adding products, quantity, options, customizable options, and bundle options

Shipping and Payment in Checkout

Address handling, shipping method selection, and payment method selection in the checkout process

Totals and Taxes

TotalsCollector, tax calculation, discount calculation, and grand total computation

Checkout Session

CheckoutSession model, session data, step management, and persistence in Magento checkout

Checkout APIs

REST APIs for cart and checkout management, cart management API, and order placement API

Checkout UI

Checkout index.xml layout, layout handles, step components, and shipping/payment step implementation

KnockoutJS in Checkout

Using KnockoutJS observables, bindings, view models, and checkout components in Magento 2

UI Components Deep Dive

Component architecture, XML configuration, JavaScript components, and data providers in Magento 2

Payment Methods

Payment method interface, authorize/capture/void operations, payment configuration, and custom payment implementation

Shipping Methods Deep Dive

Shipping methods deep dive - carrier configuration, rate calculation, handling fees

Custom Checkout Features

Custom checkout steps, custom validation, and one-step checkout patterns in Magento 2

Cart Price Rules

Cart price rules including coupons, discounts, conditions, actions, and catalog rules

Order Placement

Place order API, order creation, inventory reservation, and payment processing

Checkout Performance

Lazy loading, async operations, caching, and JavaScript optimization for checkout

Checkout Debugging

Quote to Order Conversion

Order creation from quote, order items, order totals, and the conversion process

Invoice and Shipment

Invoice creation, shipment creation, partial shipment, and tracking in Magento 2

Credit Memo

Refund creation, partial refund, refund items, and offline/online refund processing

Order States and Statuses

State transitions, custom statuses, and the order state machine in Magento 2

Order Repositories

OrderRepositoryInterface, searching orders, filtering by status, date, and customer

Order Grids

Admin order grid, custom columns, filters, mass actions, and grid data providers

Order Processing

Order workflows, state transitions, automatic invoicing, and shipment creation

Order Emails

Order confirmation, shipment notification, invoice notification, and email templates

Admin Routes

Admin route registration, front names, admin URL generation, and route configuration

Admin Controllers

Action classes, ACL checks, form handling, and grid actions in admin controllers

ACL Permissions

Resource tree, role management, permission checks in controllers, and ACL configuration

Admin Menus

menu.xml configuration, menu items, menu actions, and custom menu entries

UI Components Deep Dive

Component architecture, XML configuration, JavaScript components, and data providers in Magento 2

Grids and Listings

Listing component, columns, filters, sorting, pagination, and data sources

Forms and Data Providers

Form component, field types, data providers, and form modifiers for Magento 2 admin

Mass Actions

Delete, update status, custom mass actions, and confirmations in Magento 2 admin

Theme Architecture Deep Dive

Understanding Magento 2 theme architecture: theme.xml, registration.php, theme inheritance, fallback mechanism, and theme configuration

Parent/Child Theme Relationship

Understanding parent/child theme inheritance in Magento 2: overriding, customization, and building custom themes from Blank or Luma

Blank and Luma Themes

Understanding Magento 2 default themes: Blank and Luma, their structure, differences, and customization approach

Layout XML Deep Dive

Comprehensive guide to Magento 2 Layout XML: handles, blocks, containers, referenceContainer, action, arguments, move, and remove operations

Blocks and Templates

Understanding Magento 2 block classes, template variables, escape methods, and template inheritance patterns

PHTML Templates

Mastering Magento 2 PHTML templates: syntax, escaping, conditionals, loops, helper methods, and layout methods

Layout Handles

Understanding Magento 2 layout handles: default, cms_index_index, catalog_product_view, custom handles, and handle hierarchy

ViewModels Deep Dive

Advanced ViewModel patterns in Magento 2: dependency injection, clean architecture, multiple view models, and testing

RequireJS in Magento

Understanding RequireJS configuration in Magento 2: requirejs-config.js, paths, shim, dependencies, and async loading

AMD Modules in Magento

Understanding AMD module pattern in Magento 2: define, require, module patterns, and Magento JavaScript architecture

KnockoutJS Deep Dive

Advanced KnockoutJS in Magento 2: observables, computed, bindings, components, and custom bindings

UI Components JS Deep Dive

Advanced Magento 2 UI Components: component lifecycle, mixins, extending components, and custom component creation

JavaScript Mixins

Understanding JavaScript mixins in Magento 2: mixin configuration, extending JS components, and the plugin system for JavaScript

LESS/CSS in Magento

Understanding LESS and CSS in Magento 2: compilation, variables, mixins, responsive design, and custom styles

Static Content Deployment

Understanding Magento 2 static content deployment: setup:static-content:deploy, compilation modes, and performance optimization

Cache Busting

Understanding cache busting in Magento 2: version strings, file hashing, and CDN configuration

Hyvä Theme

Understanding the Hyvä theme for Magento 2: performance benefits, architecture, and replacing the Luma frontend

Tailwind CSS in Magento

Using Tailwind CSS in Magento 2: configuration, purging, utility classes, and customization

Alpine.js in Magento

Using Alpine.js in Magento 2: replacing KnockoutJS, reactive UI patterns, and component implementation

Hyvä Customization

Extending Hyvä theme: custom modules, template overrides, and integration with third-party extensions

Hyvä Compatibility

Understanding Hyvä extension compatibility: supported extensions, compatibility layers, and migration approach

Legacy vs Modern Frontend

Comparing Luma and Hyvä frontends: performance comparison, architecture differences, and migration considerations

Frontend Decision Making

Choosing the right frontend approach: when to use Luma, Hyvä, or headless architecture in Magento 2

REST API Introduction

Introduction to Magento 2 REST API: REST principles, resources, HTTP methods, and content types

Web API Routes

Understanding Magento 2 Web API routes: webapi.xml, URL patterns, route parameters, and wildcard routes

API ACL

Understanding Magento 2 API ACL: resource permissions, token-based access, and admin vs customer vs guest access

Service Contracts Exposed as API

Understanding how service contracts are exposed as REST API: defining API interfaces, webapi.xml configuration, and implementation

Authentication Tokens

Understanding Magento 2 authentication tokens: admin tokens, customer tokens, integration tokens, and token lifecycle

REST CRUD Operations

Implementing REST CRUD operations in Magento 2: GET/POST/PUT/DELETE for products, customers, and orders

REST Error Handling

Understanding Magento 2 REST error handling: HTTP status codes, error response format, and validation errors

Building Custom REST API

Creating custom REST API in Magento 2: API interface, webapi.xml route, ACL, and implementation

GraphQL Introduction

Introduction to GraphQL in Magento 2: schema, types, queries, mutations, and resolvers

GraphQL Queries

Working with Magento 2 GraphQL queries: products, categories, customer, and cart queries

GraphQL Mutations

Performing Magento 2 GraphQL mutations: add to cart, place order, update customer, and custom mutations

GraphQL Schema

Understanding Magento 2 GraphQL schema: type definitions, interfaces, input types, and custom types

GraphQL Resolvers

Understanding Magento 2 GraphQL resolvers: resolver classes, data loading, N+1 prevention, and batching

Custom GraphQL Module

Creating custom GraphQL module in Magento 2: schema.graphqls, resolver class, and type definitions

GraphQL Caching

Understanding Magento 2 GraphQL caching: response caching, CDN caching, cache tags, and private content

REST vs GraphQL

Comparing REST and GraphQL in Magento 2: advantages, disadvantages, and when to use each approach

Events Deep Dive — Dispatching Internals

Understanding Magento 2 event dispatching internals, event data handling, observer execution order, and event debugging techniques

Observers Deep Dive — Classes, Shared Observers, and Performance

Advanced observer patterns in Magento 2: observer classes, shared observers, event arguments handling, and observer performance optimization

Plugins Deep Dive — Before, After, and Around Methods

Advanced plugin patterns in Magento 2: before/after/around plugins, plugin interception mechanics, plugin limitations, and generated code analysis

Plugin Ordering — Sort Order, Conflicts, and Resolution

Understanding plugin sort order, resolving plugin conflicts when multiple plugins target the same method, and managing plugin execution chains

Plugin vs Observer — When to Use Each

Comparing plugins and observers in Magento 2: when to use each, performance implications, testability, and limitations of each approach

Plugin vs Preference — When to Use Each

Comparing plugins and preferences in Magento 2: when to use plugins vs class preferences, preference limitations, and plugin advantages

Extension Attributes — Custom Attributes for Existing Entities

Adding custom attributes to existing Magento 2 entities using extension attribute interfaces and implementing extension attribute storage

Extension Trade-offs — Decision Matrix

Comparing plugins, observers, preferences, and service contracts in Magento 2 with a decision matrix for choosing the right extension approach

Cron Introduction — Scheduled Tasks in Magento 2

Understanding what cron is, how Magento runs scheduled tasks, crontab.xml configuration, and cron groups in Magento 2

Cron Groups — Configuration and Concurrent Runs

Configuring cron groups in Magento 2: default and custom groups, group configuration options, concurrent run management, and performance tuning

Scheduling Cron Jobs — Expressions and Schedule Management

Scheduling cron jobs in Magento 2: cron expression syntax, schedule management, missed schedule handling, and cron job configuration

Cron Debugging — Logs, Status, and Performance

Debugging cron jobs in Magento 2: cron logs, schedule status monitoring, common cron issues, and performance debugging

Message Queues — Asynchronous Processing in Magento 2

Configuring and using message queues in Magento 2: queue configuration, message publishing, queue consumers, and async operations patterns

RabbitMQ Integration — Magento 2 Message Broker

Integrating RabbitMQ with Magento 2: connection setup, exchanges, queues, bindings, and production configuration

Queue Consumers — Configuration and Management

Configuring and managing queue consumers in Magento 2: consumer configuration, consumer runners, bulk consumption, and failure handling

Async Operations — Bulk API, Indexation, and Patterns

Asynchronous operations in Magento 2: bulk API, async indexation, async operation patterns, and performance optimization

Indexers Introduction — What Indexers Are and Why They Exist

Understanding Magento 2 indexers: what they are, why they exist, indexer types, and how indexers improve store performance

Index Modes — Update on Save vs Update by Schedule

Understanding Magento 2 index modes: real-time (Update on Save) vs scheduled (Update by Schedule), mode selection, and trade-offs

Reindexing — Full, Partial, and Performance

Reindexing in Magento 2: full reindex, partial reindex, reindex performance optimization, and debugging reindex issues

Custom Indexers — Creating Your Own Indexer

Creating custom indexers in Magento 2: IndexerInterface, data providers, indexer configuration, and implementing custom indexing logic

Cache Types — Configuration, Block HTML, and Custom Caches

Understanding Magento 2 cache types: configuration cache, layout cache, block HTML cache, page cache, and creating custom cache types

Redis in Magento 2 — Cache Backend and Session Storage

Configuring Redis in Magento 2: cache backend, session storage, full page cache, and Redis performance optimization

Varnish Integration — VCL Configuration and Cache Invalidation

Integrating Varnish with Magento 2: VCL configuration, cache invalidation, TTL settings, grace handling, and production deployment

Cache Tags — Tag-Based Invalidation and Cache Identity

Understanding cache tags in Magento 2: tag-based invalidation, cache identity, tag implementation, and tag-based cache management

Full Page Cache — FPC Mechanism and Hole Punching

Understanding Magento 2 Full Page Cache: FPC mechanism, hole punching, ESI integration, and private content handling

Private Content — Customer Sections and Dynamic Blocks

Handling private content in Magento 2: customer sections, section API, dynamic blocks, and private content loading patterns

Cache Invalidation — When and How Cache Clears

Understanding cache invalidation in Magento 2: when cache clears, tag-based invalidation, cache stampede prevention, and invalidation strategies

Cache Debugging — Hit Ratio, Status, and Performance

Debugging cache in Magento 2: cache hit ratio, cache status monitoring, debugging tools, and performance impact analysis

Search Introduction — Catalog Search Architecture

Understanding Magento 2 search system: catalog search, search engine integration, search architecture, and search configuration

OpenSearch/Elasticsearch — Installation and Configuration

Installing and configuring OpenSearch/Elasticsearch for Magento 2: installation, configuration, index management, and performance tuning

Search Indexes — Product, Category, and Suggestions

Understanding search indexes in Magento 2: product index, category index, search suggestions, synonyms, and index management

Custom Search — Customization and Relevance Tuning

Implementing custom search in Magento 2: custom search functionality, search customization, relevance tuning, and advanced search features

Authentication in Magento

CSRF and XSS Protection

SQL Injection Prevention

Input Validation

API Security

Admin Security

Security Patches

Security Audit

Unit Tests in Magento

Integration Tests

Functional Tests

API Tests

Magento Functional Testing Framework

Test Fixtures

Test Pyramid

CI Testing

Magento Logs

Developer Mode

Xdebug Setup

Browser DevTools

Network Debugging

Database Debugging

Layout Debugging

Checkout Debugging

Performance Budgets