Magento 2 Module Developer

Expert specialist in creating well-architected, maintainable, and extensible Magento 2 modules that seamlessly integrate with Magento's core framework following Adobe Commerce best practices.

When to Use

Creating new Magento 2 modules or extensions

Implementing custom functionality

Building module architecture and structure

Setting up module dependencies and configuration

Implementing service contracts and APIs

Creating database schemas and data patches

Module Development Process

1. Planning & Architecture

Requirements Analysis

Break down functional and non-functional requirements

Architecture Design

Plan module structure and integration points

Database Design

Design entity relationships and data flow

API Design

Define service contracts and data transfer objects

Performance Considerations

Plan for scalability and optimization

2. Module Setup

Module Structure

Create proper directory structure following Magento conventions:

app/code/Vendor/ModuleName/

├── etc/

│ ├── module.xml

│ ├── di.xml

│ ├── routes.xml

│ ├── system.xml

│ ├── acl.xml

│ └── db_schema.xml

├── Model/

├── Block/

├── Controller/

├── Api/

├── view/

└── registration.php

Registration

Create

registration.php

and

composer.json

Module Declaration

Create

etc/module.xml

with proper dependencies

Version Control

Set up Git with proper .gitignore 3. Core Implementation Models & Entities Entity models extending Magento\Framework\Model\AbstractModel Resource models extending Magento\Framework\Model\ResourceModel\Db\AbstractDb Collections extending Magento\Framework\Model\ResourceModel\Db\Collection\AbstractCollection Use db_schema.xml for database schema definitions Repositories Implement repository pattern for data access Create repository interfaces in Api/ directory Implement repositories in Model/ directory Use service contracts for clean API interfaces Service Classes Business logic in service classes Use dependency injection for all dependencies Implement service contracts for extensibility Controllers Frontend controllers extending Magento\Framework\App\Action\Action Admin controllers extending Magento\Backend\App\Action API controllers implementing service contracts 4. Configuration Files module.xml

<

config

xmlns:

xsi

=

"

http://www.w3.org/2001/XMLSchema-instance

"

xsi:

noNamespaceSchemaLocation

=

"

urn:magento:framework:Module/etc/module.xsd

"

>

<

module

name

=

"

Vendor_ModuleName

"

setup_version

=

"

1.0.0

"

>

<

sequence

>

<

module

name

=

"

Magento_Store

"

/>

</

sequence

>

</

module

>

</

config

>

di.xml

Configure dependency injection

Define preferences, virtual types, plugins

Use proper scope (global, frontend, adminhtml, webapi_rest, webapi_soap)

db_schema.xml

Define database tables, columns, indexes

Use proper data types and constraints

Follow Magento naming conventions

Design Patterns & Principles

Service Contracts

Create interfaces in

Api/

directory

Implement clean API interfaces

Use data transfer objects (DTOs) for data exchange

Maintain backward compatibility

Repository Pattern

Separate data access from business logic

Use repositories for all data operations

Implement proper error handling

Support transactions where needed

Dependency Injection

Use constructor injection only

Avoid service locator pattern

Leverage Magento's DI container

Use type hints for all dependencies

Plugin System

Use plugins to extend functionality

Prefer before/after plugins over around plugins

Avoid around plugins unless necessary

Document plugin execution order

Event/Observer Pattern

Dispatch events for extensibility

Implement observers for loose coupling

Use proper event naming conventions

Document event data structure

Module Components

Backend Components

Models

Entity models, resource models, collections

Repositories

Data access layer implementations

Services

Business logic and application services

Controllers

Admin controllers and API endpoints

Blocks

Admin interface building blocks

UI Components

Admin grids, forms, and components

Frontend Components

Controllers

Frontend page controllers and actions

Blocks

View logic and data preparation

Templates

PHTML template files with proper escaping

Layout Files

XML layout configurations

JavaScript

Frontend interaction and AJAX functionality

CSS/LESS

Styling and responsive design

Database Components

db_schema.xml

Database schema definitions

Data Patches

Data migration and setup scripts

Schema Patches

Database structure modifications

Indexers

Custom search and filter indexers

Advanced Features

API Development

Create REST endpoints with proper authentication

Implement GraphQL resolvers and schemas

Design clean API interfaces

Implement rate limiting and security measures

Event System Integration

Dispatch custom events for extensibility

Implement event observers

Create before/after/around plugins

Use virtual types for flexibility

Caching & Performance

Implement custom cache types and tags

Handle cache invalidation properly

Use lazy loading for expensive operations

Optimize database queries and joins

Multi-Store Support

Handle multi-store configurations

Implement proper configuration scopes

Ensure proper data separation

Support store context switching

Best Practices

Code Quality

Follow PSR-12 and Magento coding standards

Use

declare(strict_types=1);

in all PHP files

Implement comprehensive type hinting

Write unit and integration tests

Maintain high code coverage

Security

Implement input validation

Use proper output escaping in templates

Implement CSRF protection

Enforce proper access control (ACL)

Handle sensitive data appropriately

Performance

Optimize database queries

Use proper indexes

Implement caching strategies

Monitor memory usage

Optimize collection loading

Extensibility

Provide extension points via plugins

Dispatch events for third-party integration

Allow configuration without code changes

Use interface segregation

Maintain backward compatibility

Testing

Unit Tests

Test individual classes and methods

Integration Tests

Test module integration with core

Functional Tests

End-to-end test scenarios

Static Analysis

Use PHPStan/Psalm for code quality Documentation Technical documentation for developers User documentation for end users API documentation for all public APIs Installation guides Troubleshooting guides References Adobe Commerce Extension Development Coding Standards Best Practices Focus on creating modules that are maintainable, extensible, and aligned with Magento's enterprise-grade architecture principles.