ARTICLE

Adobe Commerce App Builder: Building Out-of-Process Magento Extensions With Starter Kits and Runtime Actions

developer working at a standing desk in a modern Brooklyn office with exposed brick walls and large windows

Adobe Commerce App Builder is Adobe’s serverless framework for building extensions that run outside the Commerce codebase, connecting to Magento through events, webhooks, and REST or GraphQL APIs rather than PHP plugins and observers. It eliminates the upgrade friction that comes with in-process modules by keeping custom logic in isolated JavaScript runtime actions that deploy independently of the core application.

What App Builder Actually Is

App Builder is a serverless development platform hosted on Adobe I/O Runtime. It gives Adobe Commerce developers a way to write business logic as Node.js functions (called runtime actions) that execute in response to Commerce events, scheduled triggers, or direct API calls. The runtime handles scaling, infrastructure, and execution. Your code runs in containers that spin up on demand and shut down when idle.

The core components are:

  • Runtime actions that execute your business logic as serverless functions
  • Adobe I/O Events that stream Commerce events (order placed, customer created, product updated) to your actions in near real time
  • API Mesh that lets you compose multiple APIs into a single GraphQL endpoint your storefront can query
  • Admin UI SDK that injects custom menus and pages into the Commerce admin panel without modifying admin templates
  • Out-of-process extensibility modules (OOPE) that handle payment methods, shipping carriers, tax calculation, and custom attributes through external services

This is not a theoretical framework. Adobe ships it as the default extensibility model for Adobe Commerce as a Cloud Service, where in-process customization is not an option at all.

The Integration Starter Kit: What Ships in the Box

Adobe provides a pre-built starter kit that handles bidirectional sync for six core entities: Customer, Customer Group, Order, Product, Shipment, and Stock. Instead of writing the event subscription, transformation, and error handling plumbing from scratch, you clone the kit and customize the parts that differ for your integration.

The directory structure follows a consistent pattern:

Directory Purpose
actions/<entity>/commerce/ Handles events originating in Commerce, syncs data to the external system
actions/<entity>/external/ Handles events from the external system, updates Commerce
actions/<entity>/actions.config.yaml Declares runtime actions and their event bindings for that entity
scripts/onboarding/ Automated setup and configuration
scripts/commerce-event-subscribe/ Subscribes the Commerce event provider to specific events
test/actions/ Unit tests for runtime actions

Each action directory contains a predictable set of files. The index.js entry point coordinates validation, transformation, and the target API call. A transformer.js handles payload mapping between Commerce and external formats. The sender.js calls the target API. And pre.js and post.js provide extension points for custom logic before and after the API call, so you can add business rules without touching the core sync flow.

Event registration lives in scripts/onboarding/config/starter-kit-registrations.json. You edit this file to add, remove, or change which Commerce events your integration listens to. The onboarding script reads it and creates the necessary subscriptions in Adobe Developer Console automatically.

When to Use App Builder vs a PHP Module

The practical split that experienced teams land on is roughly 70% App Builder, 30% in-process PHP. The dividing line is straightforward: if the logic needs direct database access, synchronous latency under a few milliseconds, or tight coupling to the checkout request lifecycle, it stays in PHP. Everything else moves out.

App Builder fits best for:

  • ERP, CRM, and OMS integrations where data syncs asynchronously
  • Identity and SSO orchestration (Keycloak, Okta, Azure AD)
  • Customer and company validation against external services (Dun & Bradstreet, credit checks)
  • Product availability resolution from PIM or warehouse systems
  • Background jobs and scheduled exports (order feeds to fulfillment, inventory snapshots)
  • Redirect engines and URL management automation
  • Custom admin dashboards and reporting tools

PHP modules remain the right choice for:

  • Checkout and order placement adjustments that must execute synchronously
  • Pricing, cart, and quote logic where latency matters
  • Deep GraphQL resolver customization that needs direct model access
  • Performance-sensitive hooks where adding an HTTP round trip is not acceptable

The key benefit of moving integrations to App Builder is deployment independence. When your ERP sync logic lives in a PHP module, every change requires a full Commerce deployment cycle. With App Builder, you deploy the action independently. If the ERP goes down, Commerce keeps running. If Commerce is upgrading, your integrations keep running. Failure isolation is built into the architecture.

The Admin UI SDK: Custom Admin Without PHP Templates

The Admin UI SDK lets App Builder applications inject custom menus and pages directly into the Commerce admin panel. This replaces the traditional approach of building adminhtml layouts, controllers, and UI components in PHP.

The SDK uses two components: a small in-process PHP module called CommerceBackendUix that handles the menu injection and routing, and a React application that renders your custom admin content. Authentication goes through Adobe Identity Management Service (IMS), so your App Builder app communicates securely with the merchant’s Commerce instance.

Practical use cases include:

  • Custom reporting dashboards pulling data from external analytics platforms
  • ERP integration management interfaces where merchants configure sync rules
  • Workflow automation panels for order routing, content publishing, or inventory updates
  • Bulk editing tools for product attributes or pricing across catalogs

This matters because admin customization has historically been one of the most brittle parts of Magento upgrades. Admin UI components built through the SDK are decoupled from Commerce’s admin theme, so they survive version upgrades without rework.

Out-of-Process Extensibility Modules

Adobe ships a set of OOPE modules that extend Commerce’s core domain objects through external services. These modules handle the REST API and GraphQL plumbing so your App Builder actions can register as payment methods, shipping carriers, tax providers, or custom attribute sources without writing a traditional Magento module.

The available OOPE modules cover:

Module What It Does
Payment Methods Registers external payment methods through REST, extends checkout via GraphQL, supports filtering webhooks
Shipping Methods Registers out-of-process carriers whose webhooks fetch real-time rates
Tax Lets an external tax service drive quote tax calculation through a REST registry
Custom Attributes Attaches and persists custom attributes to entities, with a separate B2B metapackage for negotiable quotes and companies
Totals Collector Modifies quote totals (primarily discounts) through webhooks
Observability Manages OTLP endpoints for routing logs, metrics, and traces
API Integration Exposes order status endpoints with status name, label, state, and storefront visibility

These modules come included by default on Adobe Commerce as a Cloud Service. For cloud infrastructure and on-premises deployments, you install them separately through Composer.

How Events and Webhooks Connect the Pieces

The event-driven architecture is what makes App Builder practical rather than theoretical. Commerce fires events when entities change. Your App Builder actions subscribe to those events and execute in response. The flow looks like this:

  1. A customer places an order in Commerce
  2. Commerce fires an observer.sales_order_save_after event
  3. Adobe I/O Events routes the event to your subscribed runtime action
  4. Your action transforms the order data and sends it to your ERP
  5. If the ERP responds with updated shipping details, a second action pushes those back to Commerce through the REST API

Webhooks work synchronously for cases where Commerce needs an immediate response. When a customer reaches checkout, Commerce can call a webhook to your App Builder action to fetch shipping rates from an external carrier, filter available payment methods based on customer segment, or calculate tax from a third-party tax engine. The response comes back in the same request cycle.

The difference matters: events are fire-and-forget (asynchronous), webhooks are request-response (synchronous). Use events for integrations where a few seconds of delay is acceptable. Use webhooks when Commerce needs the answer before it can continue rendering the page.

What Changes for Your Hyva Frontend

App Builder’s backend changes are invisible to the Hyva frontend in most cases. Your Alpine.js components still call the same GraphQL endpoints. The OOPE modules extend those endpoints transparently, so a shipping method registered through App Builder appears in the available_shipping_methods query just like a native carrier.

Where it gets interesting is API Mesh. If your Hyva storefront needs data from both Commerce and an external system (product availability from a warehouse API, personalized pricing from a PIM), API Mesh composes those into a single GraphQL endpoint. Your frontend makes one query instead of orchestrating multiple API calls in JavaScript.

For teams running Hyva on Adobe Commerce, this is the cleanest path to adding external data sources without complicating the frontend architecture.

The Practical Tradeoffs

App Builder is not free of costs. The tradeoffs are real and worth understanding before committing:

Architecture complexity increases. You are adding a layer. API Mesh becomes a central dependency. Your team needs to understand Adobe I/O Events, runtime action configuration, and the Developer Console. The mental model shifts from “modify the PHP class” to “configure an event subscription, write an action, deploy it separately, and monitor it independently.”

Asynchronous behavior requires handling. When orders sync to the ERP through events rather than a direct database write, there is a delay. Your team needs retry logic, dead-letter queues for failed events, and monitoring dashboards to catch sync failures before merchants notice.

Technology stack expands. App Builder actions are Node.js, not PHP. Teams that are purely PHP-focused will need to build JavaScript competency or bring in developers who already have it. The testing patterns differ too: unit tests for runtime actions use Jest, not PHPUnit.

Not available on Magento Open Source. App Builder requires an Adobe Commerce license. If you are running the open-source edition, the traditional extensibility approach with plugins, observers, and preferences remains your path.

Upgrade benefits are substantial. The whole point of moving logic out of process is that Commerce upgrades no longer break your customizations. When Adobe releases a new version, your runtime actions keep running unchanged. This alone can justify the architectural investment for merchants who have been burned by upgrade cycles that take months because every custom module needs retesting.

Getting Started: The Minimum Path

The fastest way to evaluate App Builder for your Adobe Commerce project:

  1. Provision App Builder through the Adobe Developer Console (requires an Adobe Commerce license with App Builder entitlement)
  2. Clone the integration starter kit and configure it for one entity (start with Customer or Product)
  3. Run the onboarding script to set up event subscriptions
  4. Write a simple runtime action that logs incoming events to verify the pipeline works
  5. Customize the transformer and sender for your specific external system

The starter kit handles the boilerplate. Your job is mapping data between Commerce and your systems, writing the business rules in pre.js and post.js, and setting up monitoring for production.

For Shopify or Shopware merchants evaluating a move to Adobe Commerce, App Builder is part of what makes the platform comparison relevant. The ability to integrate without core modifications changes the total cost of ownership calculation, especially for B2B operations with complex ERP requirements.

If your team needs help evaluating whether App Builder fits your integration architecture, Bemeir’s Adobe Commerce specialists can walk through your current customizations and map which ones move out of process and which stay in PHP. As an official Adobe Commerce and Hyva Gold partner, we have built these architectures for merchants running everything from mid-market DTC stores to enterprise B2B portals.

FAQ

Does App Builder work with Magento Open Source?

No. App Builder requires an Adobe Commerce license with App Builder entitlement. Magento Open Source merchants continue using traditional in-process extensibility with PHP modules, plugins, and observers. The out-of-process extensibility modules are only available on Adobe Commerce.

How much does App Builder cost beyond the Adobe Commerce license?

App Builder is included with Adobe Commerce as a Cloud Service subscriptions. For self-hosted Adobe Commerce, you need an App Builder entitlement, which Adobe bundles with certain license tiers. Runtime action execution is metered, but most Commerce integrations fall well within the included allocation. Check your specific Adobe agreement for exact entitlements.

Can I run App Builder actions locally during development?

Yes. The Adobe I/O CLI lets you run and debug runtime actions locally using VS Code. You can test actions against a development Commerce instance by configuring local event delivery. The starter kit ships with unit tests in the test/actions/ directory that run locally with standard Node.js test runners.

What happens when an App Builder action fails?

Adobe I/O Events supports retry policies for event-driven actions. If your action throws an error or times out, the event is retried according to your configured retry policy. For critical integrations, you should implement dead-letter handling in your action code and set up monitoring through the Adobe Developer Console or an external observability platform. The OOPE Observability module supports OTLP endpoints for routing logs, metrics, and traces.

Is App Builder mandatory for Adobe Commerce as a Cloud Service?

Yes, for custom extensions. Adobe Commerce as a Cloud Service does not support in-process PHP customizations, so all custom logic must run through App Builder or be handled by the OOPE modules. This is a fundamental architectural difference from self-hosted Adobe Commerce, where you still have the choice between in-process and out-of-process approaches.

Let us help you get started on a project with Adobe Commerce App Builder: Building Out-of-Process Magento Extensions With Starter Kits and Runtime Actions and leverage our partnership to your fullest advantage. Fill out the contact form below to get started.

more articles about ecommerce

Read on the latest with Shopify, Magento, eCommerce topics and more.