Magento Open Source Adobe Commerce Storefront design & front-end Independent · not affiliated with Adobe
Magento Themes Store Storefront Lab
Published 13 Nov 2026 10 min read

Hiring a Magento developer: what to test for

A sound Magento hire should protect upgradeability, isolate custom code and make operational risks visible before committing a production store to their work.

What you are actually buying

Magento development is not simply PHP work with a product catalogue attached. A capable developer should be able to change a store without tying it to one extension, one hosting stack or one undocumented deployment ritual. They should also leave behind a project another competent developer can understand and deploy.

That matters more than fluency in Magento syntax. Many damaging changes look competent in a pull request and become awkward six months later, when an extension needs replacing or the platform is upgraded. The screening process should therefore test judgement, not just recall.

The current general release is Magento Open Source and Adobe Commerce 2.4.9. A developer working on a current store should be able to discuss its supported stack without guessing. For on-premises 2.4.9, Adobe lists PHP 8.5, MariaDB 12.3 or MySQL 8.4, OpenSearch 3, Valkey 9 for cache and sessions, RabbitMQ 4.3 and Composer 2.10. Elasticsearch and Redis are not listed as supported for 2.4.9.

This is not a licence to reject every existing extension immediately. It is a reason to ask what the developer will verify, what they will replace and how they will prove the resulting store works.

Test their Magento architecture

1. How should custom code enter the project?

Ask: “How do you structure a Magento project, and what belongs in version control?”

A good answer will describe a Composer-managed project rather than a directory full of copied module files. Dependencies should be declared and reproducible. Application code should be separated from vendor code, with deployment configuration handled deliberately.

The answer should also distinguish custom modules from third-party packages. A developer who says they will “install the files and commit them” may know how to copy a module across environments, but has not necessarily considered dependency versions, patch conflicts or the cost of replacing an extension later.

Press further: “When an extension does something almost right, what do you change?” The strong answer is to isolate the necessary behaviour in a small, owned module rather than editing the vendor directory. If an extension cannot be configured safely, it may need replacing. That decision should follow from its maintenance, behaviour and importance, not convenience.

2. What do they know about dependency injection and plugins?

Ask: “How would you add behaviour without rewriting a core class?”

A good answer should reach for the appropriate Magento extension mechanism before changing core code. Plugins can wrap eligible public methods with behaviour before or after they run. Preferences can replace an interface implementation. Events and observers can connect modules without altering unrelated code.

Do not accept an answer that treats every problem as a plugin. Plugins have limits and can add overhead when poorly targeted. Nor should they recommend rewriting a core class because it is the quickest route. The good answer will establish where the behaviour belongs, identify the narrowest integration point and consider whether the dependency remains replaceable.

Useful follow-up: “How do you find out whether a class has been rewritten?” The developer should expect to inspect preferences, plugin declarations and code coverage, not merely search for the original class name. A vendor file that differs from the distribution is a direct warning.

3. Do they understand indexes and cache?

Ask: “When catalogue or search data is stale, what do you investigate?”

A good answer starts with the indexers and the relationship between source data, index data and cache. It should not jump immediately to “clear the cache” as a universal remedy. They should ask what changed, which indexer owns the affected data, whether reindexing is safe and why the result differs between environments.

The answer should distinguish the main cache from other cache types and application caches, including cache used for sessions. It should also acknowledge that clearing a cache can temporarily increase work such as cache regeneration.

Ask how they would diagnose repeated invalidation rather than merely clean it repeatedly. A competent response will look for code writing to the wrong cache, excessive object creation, third-party behaviour and differences between production and staging configuration. The aim is to remove the cause, not preserve a ritual of cleaning everything after every deployment.

Test their upgrade judgement

4. How would you move a store from 2.4.6?

Ask for the first three actions, not a promise of a painless upgrade. Regular support for 2.4.6 ended on 11 August 2026, so the discussion should acknowledge that it is no longer the current supported target.

A good answer begins with an inventory: custom modules, third-party extensions, themes, payment integrations, deployment tooling, cron jobs and the current system requirements. The developer should check extension compatibility with 2.4.9 and the supported PHP, database, search, cache, session, messaging and Composer stack.

They should also plan how the store will be tested during the move. That includes checkout paths, taxes, shipping, promotions, customer accounts, admin workflows, search, indexing, scheduled tasks, email and any integrations outside Magento. Static content and deployment behaviour deserve attention too; an otherwise successful upgrade can still leave the storefront broken if assets were not generated or deployed properly.

Expect a staged approach with a defined rollback point. The developer should distinguish an upgrade rehearsal from the production cut-over and explain how they would compare behaviour before and after. If the answer begins with “copy the new files over the old installation”, stop the interview.

A strong developer will also identify what cannot safely be automated. Magento data schema changes, obsolete extensions and custom code can make scripted runs unreliable. The objective is not to minimise manual work blindly; it is to make each consequential step repeatable and visible.

5. How do they prepare for a missed extension deadline?

Ask: “What do you do when a critical extension will not support the target release?”

The good answer will assess the extension’s role, available alternatives and the cost of delaying. Replacing a checkout, payment or tax component can be substantial. Patching an unsupported extension may be quicker but can leave the store with an unmaintained dependency. Neither option should be presented as risk-free.

They should involve you in the decision and record the outcome. If no clean path exists, the honest recommendation may be to stabilise the existing store temporarily while preparing a replacement. That is different from quietly carrying unsupported code forward and calling the upgrade complete.

Test their front-end competence

6. Can they work with both Luma and Hyvä?

Ask: “How do Luma and Hyvä differ technically, and where would you customise each?”

A sound answer will identify Luma as the default Magento storefront theme, built with LESS, Knockout.js and RequireJS, with Blank as its parent theme. It should explain that this differs from Hyvä, which uses Tailwind CSS and Alpine.js. Hyvä became free and open source on 10 November 2025; Hyvä Checkout, Hyvä Commerce and Hyvä Enterprise remain separate paid products.

The distinction matters because theming and checkout are not the same subject. A developer may be excellent at changing a Luma template and still need to learn a different architecture. Another may understand Hyvä’s front end but have limited experience of Magento’s Knockout-based components and Luma’s extension conventions.

Ask for the trade-off they would make in a specific store. Would they retain a necessary extension and accept its front end? Build a narrow custom module? Replace the affected component? A good answer ties the decision to maintenance, checkout complexity and expected lifespan rather than declaring one stack universally better.

For a headless requirement, they should also recognise PWA Studio as Adobe’s React-based headless storefront toolkit. That is a separate architectural commitment, not a cosmetic alternative to selecting a theme.

7. Can they explain a front-end change beyond the visual result?

Ask: “How would you add a component that remains usable and maintainable?”

The answer should cover the template, JavaScript behaviour, data source, accessibility, responsive behaviour and tests. For Luma, they should know how Knockout components and RequireJS dependencies fit together. For Hyvä, they should understand Alpine.js state and Tailwind styling conventions.

Look for resistance to copying a working snippet without checking its ownership and lifecycle. A component should not become an accidental dependency on a page block or a one-off template override. Front-end customisation is architecture as well as appearance.

Test how they operate

8. What does their delivery and deployment process look like?

Ask: “Walk me through a change from ticket to production.”

A good answer should include a branch, review, automated or repeatable checks, a test environment, deployment instructions and a production verification step. Direct deployment from a developer workstation may still occur in some workflows, but the process should make the deployed state identifiable and recoverable.

They should know what they will test. For a catalogue change, that might involve the affected product, variants, search and index data. For a checkout change, it should include the relevant order path, totals, payment method and admin order view. “It works locally” is not sufficient evidence.

Ask what evidence they leave after deployment. Version-control history, migration records, configuration changes and a concise release note can be more useful than a long chat message. The record should make it possible to answer what changed, why it changed and how to reverse it.

9. What happens when they cannot reproduce a fault?

A good answer starts with observability and narrowing, not blaming the cache. They should compare environment versions, configuration, extensions, logs, data and recent changes. They should preserve useful evidence before a restart or cache clean destroys it.

The answer should also include communication. A competent developer can say what is known, what is not known, which test would distinguish two causes and when the next update will arrive. “Send me access” is not a diagnosis.

Agency, freelance or in-house?

Agency

An agency is best suited when the work needs several disciplines at once, such as a platform upgrade, checkout replacement, design work, integration delivery and ongoing operational ownership. The advantage is the range of skills and the ability to put a named specialist on a problem. The cost is that you must control scope and communication more carefully.

Assess the people who will do the work, not only the pitch team. Ask who is accountable, who has supported this exact kind of Magento work and what remains after handover. An agency without clear ownership of production can leave the client with a large invoice and an undocumented system.

Freelancer

A strong freelancer can be the right choice for a well-defined module, upgrade preparation, performance investigation or short-term specialist task. Depth and flexibility are genuine advantages. The risks are continuity, availability and dependence on one person’s undocumented knowledge.

Test that they work in a way another developer could inherit. Require version control, clear instructions and a handover. If the proposed arrangement depends on shared credentials, private scripts or immediate access to one workstation, the store is more fragile than it appears.

In-house

In-house development is best when Magento knowledge must remain close to the business and the work is continuous rather than episodic. It gives direct control over priorities and releases. It also makes recruiting and retaining scarce Magento capability the central constraint.

The in-hire should still pass the same technical screens. Ownership of the roadmap does not compensate for weak upgrade, testing or front-end judgement. Ask how they will cover holidays, departures and specialist problems, such as payment, search infrastructure or complex checkout integrations.

Warning signs that should stop the process

  • No staging environment: If there is nowhere to rehearse a deployment or upgrade, each release is an uncontrolled experiment.
  • Direct edits on production: An urgent fix made outside version control may solve today’s symptom while erasing the ability to audit or reproduce the change.
  • No version control: If code, configuration and deployment changes cannot be reviewed or restored, the project has no reliable history.
  • Core modifications: Rewritten core classes, patched vendor files and unexplained changes to distributed code make upgrades and security maintenance harder.
  • Cache cleaning as the answer: A developer who cannot diagnose invalidation or stale indexes is treating the symptom rather than the cause.
  • No written handover: If only the developer knows how the store is configured and deployed, the arrangement creates avoidable operational risk.

The best candidate is not necessarily the person who knows the most named commands. It is the one who can identify uncertainty, choose the least invasive durable change, show how it was tested and explain what could still fail. That judgement is what protects the store after the interview ends.

Questions this page answers

How should a Magento project structure custom code?
Use a Composer-managed project with declared, reproducible dependencies, separate application code from vendor code and deliberate deployment configuration.
What should be done when an extension almost meets a requirement?
Isolate the required behaviour in a small, owned module rather than editing the vendor directory. Replace the extension if it cannot be configured safely.
What should a developer do when a critical extension will not support the target release?
Assess the extensionu2019s role, available alternatives and the cost of delaying. Involve you in the decision and record the outcome; neither patching nor replacement is risk-free.
How should stale catalogue or search data be investigated?
Start with the indexers and the relationship between source data, index data and cache. Determine what changed, which indexer owns the affected data and whether reindexing is safe.

More in Platform choices

Editorial & corrections: [email protected]