Skip to content
Magento | Shopify | WordPress

Magento 2 modules, Shopify apps and WordPress plugins written against the extension points the platform documents, so an upgrade is a Tuesday rather than a project.

How engagements work

In one paragraph

What makes a custom module safe to upgrade?

Using the extension points the platform documents, and nothing else. On Magento 2 that means plugins, observers, preferences used sparingly, dependency injection as intended, declarative schema for database changes and no core overrides at all. On Shopify it means the Admin and Storefront APIs with webhooks and rate limiting handled, rather than script injection into a theme. On WordPress it means hooks and filters rather than edits to a parent theme. The practical test is the same everywhere: a minor version upgrade should not require touching your code, and if it does, the module was written around the platform instead of through it.

What this is

Nearly every store reaches a point where the thing it needs does not exist. The marketplace extension does eighty percent of it, the remaining twenty percent is the part the business actually competes on, and the options are a module or a compromise.

The risk with a module is not writing it. It is carrying it. A module written against the documented extension points costs almost nothing at upgrade time; one written by overriding core classes costs a regression hunt on every release, forever, and the cost arrives long after whoever wrote it has moved on.

So the work here is as much about restraint as construction: the smallest module that solves the problem, built on the supported surface, with tests around the behaviour the business depends on and documentation aimed at whoever inherits it.

What this page is not

A module is sometimes the wrong answer, and the cheapest version of this conversation establishes that first. If the platform already does it, or an existing extension does it well, the honest recommendation is to configure rather than build.

What usually brings this in

  • Every Magento upgrade turns into a week of regression hunting.

    Custom code overrides core classes, so each release breaks something, and upgrades get deferred until security forces one.

  • We bought an extension and it does eighty percent of the job.

    The remaining twenty percent is being done by hand every day, and the extension cannot be modified safely.

  • Nobody knows what the custom module actually does.

    No tests, no documentation, and the person who wrote it has left. It is load-bearing and untouchable.

  • Two modules fight over the same behaviour.

    Behaviour depends on load order, which means it changes when something unrelated is installed.

What gets built

Magento 2 modules on the supported surface
Plugins, observers, dependency injection, declarative schema and service contracts. Preferences only where no plugin point exists, and core overrides never. The result upgrades cleanly because it never reached into anything that moves.
Shopify private and custom apps
Admin and Storefront API applications deployed under your account, with webhook verification, idempotency and rate-limit backoff handled, rather than a theme snippet pretending to be an integration.
WordPress and WooCommerce plugins
Hooks and filters, correct capability checks, nonces and sanitisation on everything that touches input, and no edits to a theme that will be updated.
Rescuing an existing module
Read what is there, document the behaviour the business actually depends on, write tests around it, then refactor off the core overrides. Rewriting blind is how a working feature gets lost.
Admin interfaces your team can use
Configuration in the platform admin where it belongs, with sensible defaults, so changing behaviour is a setting rather than a deployment.
Documentation and handover
What it does, which extension points it uses, what will break it, and how to test it. Written for the next developer, who is usually not me.

Technologies

Magento
  • PHP
  • Dependency Injection
  • Plugins
  • Declarative schema
  • GraphQL
Shopify
  • Admin API
  • Storefront API
  • Webhooks
  • Node.js
  • OAuth
WordPress
  • Hooks
  • Filters
  • WooCommerce
  • REST API
Quality
  • PHPUnit
  • Static analysis
  • Git
  • CI pipelines

How delivery runs

  1. Scope, in writing

    What the work is, and what it explicitly is not. The second half is the one that protects both of us, and it is written before anything is quoted.

  2. Architecture before code

    The data model, the integration points and the failure modes, agreed on paper. Most of the expensive mistakes in commerce are made here and discovered six weeks later.

  3. Build in reviewable slices

    Work lands in increments you can see running, not in one drop at the end. You find out early if something is going the wrong way, which is when it is still cheap.

  4. Test against the real thing

    Production-shaped data, production-shaped traffic. A checkout that works on twelve test products tells you nothing about one carrying a hundred thousand.

  5. Deploy, document, hand over

    Release process written down, documentation aimed at your team rather than at me, and a defined window afterwards where fixes are mine.

Questions

How do I know whether we need a module or a configuration change?
Ask what the platform already does, and ask it before scoping. A good share of requested modules duplicate a native feature nobody knew was there, and finding that out is a short piece of work rather than a project. Where the feature genuinely does not exist, the module is the answer and the scope is usually smaller than expected.
Will a custom module survive Magento upgrades?
If it is written against plugins, observers and declarative schema, yes, and that is the explicit design goal. The modules that do not survive are the ones that override core classes, and that choice is almost always made for speed in week one and paid for every release afterwards.
Can you fix a module somebody else wrote?
Yes, and the order matters: read it, document the behaviour the business depends on, put tests around that behaviour, then change it. Refactoring an undocumented module without that first step is how a quiet working feature disappears.
Do you hand over the source code?
Always, in your repository, with the documentation. There is no arrangement here where the code stays with me.

Describe what is in front of you and you get a written scope and a figure, usually within a few days of a short call. No charge for either.

All services