diff --git a/addon/components/order-config-manager/activity-flow.js b/addon/components/order-config-manager/activity-flow.js
index 88c444cca..814a0fb79 100644
--- a/addon/components/order-config-manager/activity-flow.js
+++ b/addon/components/order-config-manager/activity-flow.js
@@ -34,7 +34,17 @@ export default class OrderConfigManagerActivityFlowComponent extends Component {
      * An array of activity codes that should not be modified.
      * @type {Array.<string>}
      */
-    @tracked immutableActivities = ['created', 'dispatched', 'started'];
+    /**
+     * Activities that cannot be edited or removed. Configs with their own lifecycle
+     * (`meta.lifecycle`) are not bound to the default dispatch activities.
+     */
+    get immutableActivities() {
+        return this.lifecycle ? [] : ['created', 'dispatched', 'started'];
+    }
+
+    get lifecycle() {
+        return this.config?.meta?.lifecycle ?? null;
+    }
 
     /**
      * The configuration data for the activity flow.
@@ -180,6 +190,12 @@ export default class OrderConfigManagerActivityFlowComponent extends Component {
         this.clearGraph({
             onAfter: () => {
                 this.flow = {};
+                // A configured lifecycle resets to its saved flow, never to the default dispatch flow.
+                if (this.lifecycle && this.config?.flow && Object.keys(this.config.flow).length) {
+                    this.deserializeFlow(this.config.flow);
+                    return;
+                }
+
                 const defaultActivities = this.getDefaultActivities();
                 this.addActivityToGraph(defaultActivities);
             },
@@ -361,7 +377,7 @@ export default class OrderConfigManagerActivityFlowComponent extends Component {
             }
         });
 
-        const rootCode = getOrderConfigFlowRootCode(deserializedFlow);
+        const rootCode = getOrderConfigFlowRootCode(deserializedFlow, this.lifecycle?.initial);
         if (rootCode && deserializedFlow[rootCode]) {
             this.addDeserializedActivityToGraph(deserializedFlow[rootCode]);
         }
@@ -823,16 +839,26 @@ export default class OrderConfigManagerActivityFlowComponent extends Component {
         const addButton = this.createAddActivityButton(activity, { x: width });
         let tools = [];
 
-        if (activity.get('code') === 'created' || activity.get('code') === 'dispatched') {
-            tools = [];
-        }
+        const code = activity.get('code');
+        const canUpdate = this.abilities.can('fleet-ops update order-config');
 
-        if (activity.get('code') === 'started' && this.abilities.can('fleet-ops update order-config')) {
-            tools = [addButton];
-        }
+        if (this.lifecycle) {
+            // The configured initial activity is the root: it can gain children but not be removed.
+            if (canUpdate) {
+                tools = code === this.lifecycle.initial ? [addButton] : [removeButton, addButton];
+            }
+        } else {
+            if (code === 'created' || code === 'dispatched') {
+                tools = [];
+            }
 
-        if (!this.immutableActivities.includes(activity.get('code')) && this.abilities.can('fleet-ops update order-config')) {
-            tools = [removeButton, addButton];
+            if (code === 'started' && canUpdate) {
+                tools = [addButton];
+            }
+
+            if (!this.immutableActivities.includes(code) && canUpdate) {
+                tools = [removeButton, addButton];
+            }
         }
 
         const activityNodeView = activityNode.findView(this.paper);
diff --git a/addon/components/order/details.hbs b/addon/components/order/details.hbs
index 1efdb1cbb..9e2ca09e4 100644
--- a/addon/components/order/details.hbs
+++ b/addon/components/order/details.hbs
@@ -44,6 +44,35 @@
                 )
             )
         }}
+    {{else if this.profile}}
+        {{#each this.profileSections key="key" as |section|}}
+            {{#if section.native}}
+                {{#let
+                    (component
+                        section.componentName
+                        resource=@resource
+                        onChange=section.onChange
+                        isLoading=@isLoading
+                        isLoadingActivity=@isLoadingActivity
+                        reloadToken=this.effectiveProofReloadToken
+                    )
+                    as |NativeSection|
+                }}
+                    <NativeSection />
+                {{/let}}
+            {{else}}
+                <LazyEngineComponent @component={{section.component}} as |ProfileSection|>
+                    <ProfileSection
+                        @resource={{@resource}}
+                        @controller={{@controller}}
+                        @permission={{get-write-permission @resource}}
+                        @isLoading={{@isLoading}}
+                        @profile={{this.profile}}
+                        @onChange={{@onDetailsChanged}}
+                    />
+                </LazyEngineComponent>
+            {{/if}}
+        {{/each}}
     {{else}}
         <RegistryYield @registry="fleet-ops:component:order:details:start" as |RegistryComponent|>
             <RegistryComponent @resource={{@resource}} @controller={{@controller}} @permission={{get-write-permission @resource}} @isLoading={{@isLoading}} />
diff --git a/addon/components/order/details.js b/addon/components/order/details.js
index 4e6976747..279bc7837 100644
--- a/addon/components/order/details.js
+++ b/addon/components/order/details.js
@@ -1,14 +1,40 @@
 import Component from '@glimmer/component';
 import { action } from '@ember/object';
 import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
 
 export default class OrderDetailsComponent extends Component {
+    @service orderPresentation;
     @tracked proofReloadToken = 0;
 
     get effectiveProofReloadToken() {
         return `${this.args.proofReloadToken ?? 0}:${this.proofReloadToken}`;
     }
 
+    /** The extension presentation profile applying to this order's config, if any. */
+    get profile() {
+        return this.orderPresentation.profileFor(this.args.resource);
+    }
+
+    /** Profile sections with the change handler each native section expects. */
+    get profileSections() {
+        const handlers = {
+            activity: this.handleActivityChanged,
+            detail: this.args.onDetailsChanged,
+            'custom-fields': this.args.onCustomFieldsChanged,
+            notes: this.args.onNotesChanged,
+            route: this.args.onRouteChanged,
+            payload: this.args.onPayloadChanged,
+            documents: this.args.onDocumentsChanged,
+            comments: this.args.onCommentsChanged,
+            metadata: this.args.onMetadataChanged,
+        };
+
+        return this.orderPresentation.renderableSectionsFor(this.profile, 'details').map((section) => {
+            return section.native ? { ...section, onChange: handlers[section.name] } : section;
+        });
+    }
+
     @action handleActivityChanged(optionsOrActivity) {
         if (typeof this.args.onActivityChanged === 'function') {
             this.args.onActivityChanged(optionsOrActivity?.activityCreated ?? optionsOrActivity);
diff --git a/addon/components/order/form.hbs b/addon/components/order/form.hbs
index 54f41171c..8fc2a1e56 100644
--- a/addon/components/order/form.hbs
+++ b/addon/components/order/form.hbs
@@ -16,6 +16,18 @@
                 RegistryYieldEnd=(component "registry-yield" registry="fleet-ops:component:order:form:end" order=@resource)
             )
         }}
+    {{else if this.profile}}
+        {{#each this.profileSections key="key" as |section|}}
+            {{#if section.native}}
+                {{#let (component section.componentName resource=@resource hiddenFields=this.hiddenFields) as |NativeSection|}}
+                    <NativeSection />
+                {{/let}}
+            {{else}}
+                <LazyEngineComponent @component={{section.component}} as |ProfileSection|>
+                    <ProfileSection @resource={{@resource}} @order={{@resource}} @controller={{@controller}} @profile={{this.profile}} @hiddenFields={{this.hiddenFields}} />
+                </LazyEngineComponent>
+            {{/if}}
+        {{/each}}
     {{else}}
         <RegistryYield @registry="fleet-ops:component:order:form:start" as |RegistryComponent|>
             <RegistryComponent @order={{@resource}} @resource={{@resource}} />
diff --git a/addon/components/order/form.js b/addon/components/order/form.js
index dadf47380..c2fbd0502 100644
--- a/addon/components/order/form.js
+++ b/addon/components/order/form.js
@@ -11,6 +11,7 @@ export default class OrderFormComponent extends Component {
     @service customFieldsRegistry;
     @service mapManager;
     @service currentUser;
+    @service orderPresentation;
     @tracked customFields;
 
     constructor() {
@@ -18,6 +19,19 @@ export default class OrderFormComponent extends Component {
         this.orderConfigActions.loadAll.perform();
     }
 
+    /** The extension presentation profile applying to this order's config, if any. */
+    get profile() {
+        return this.orderPresentation.profileFor(this.args.resource);
+    }
+
+    get profileSections() {
+        return this.orderPresentation.renderableSectionsFor(this.profile, 'form');
+    }
+
+    get hiddenFields() {
+        return this.orderPresentation.hiddenFieldsFor(this.args.resource);
+    }
+
     @action selectFacilitator(model) {
         this.args.resource.set('facilitator', model);
         this.args.resource.set('driver', null);
diff --git a/addon/components/order/form/details.hbs b/addon/components/order/form/details.hbs
index 32095e9c4..fec97dabe 100644
--- a/addon/components/order/form/details.hbs
+++ b/addon/components/order/form/details.hbs
@@ -9,7 +9,7 @@
                     @onChange={{perform this.selectOrderConfig}}
                     @placeholder={{t "order.fields.order-type-placeholder"}}
                     @triggerClass="form-select form-input"
-                    @disabled={{cannot-write @resource}}
+                    @disabled={{or (cannot-write @resource) this.orderTypeLocked}}
                     as |orderConfig|
                 >
                     <SelectOption::OrderConfig @option={{orderConfig}} />
@@ -17,8 +17,19 @@
             </div>
         </InputGroup>
 
+        {{#if this.profileDetailFields}}
+            <div class="contents">
+                <LazyEngineComponent @component={{this.profileDetailFields}} as |ProfileDetailFields|>
+                    <ProfileDetailFields @resource={{@resource}} @order={{@resource}} @profile={{this.profile}} />
+                </LazyEngineComponent>
+            </div>
+        {{/if}}
+
+        {{#if this.show.internalId}}
         <InputGroup @name={{t "order.fields.internal-id"}} @value={{@resource.internal_id}} @helpText={{t "order.fields.internal-id-help-text"}} @disabled={{cannot-write @resource}} />
+        {{/if}}
 
+        {{#if this.show.schedule}}
         <InputGroup>
             <InputLabel @labelText={{t "order.fields.schedule"}} @helpText={{t "order.fields.schedule-help-text"}} />
             <DateTimeInput
@@ -30,7 +41,9 @@
                 @disabled={{or @resource.dispatched (cannot-write @resource)}}
             />
         </InputGroup>
+        {{/if}}
 
+        {{#if this.show.customer}}
         <InputGroup @name={{t "order.fields.customer"}} @helpText={{t "order.fields.customer-help-text"}}>
             <ModelSelect
                 @modelName="customer"
@@ -48,7 +61,9 @@
                 <SelectOption::Customer @option={{model}} />
             </ModelSelect>
         </InputGroup>
+        {{/if}}
 
+        {{#if this.show.facilitator}}
         <InputGroup @name={{t "order.fields.facilitator"}} @helpText={{t "order.fields.facilitator-help-text"}}>
             <ModelSelect
                 @modelName="facilitator"
@@ -66,8 +81,9 @@
                 <SelectOption::Facilitator @option={{model}} />
             </ModelSelect>
         </InputGroup>
+        {{/if}}
 
-        {{#if (and @resource.facilitator.isIntegratedVendor @resource.facilitator.service_types.length)}}
+        {{#if (and this.show.serviceType @resource.facilitator.isIntegratedVendor @resource.facilitator.service_types.length)}}
             <InputGroup @name={{t "order.fields.service-type"}} @helpText={{concat (t "order.fields.service-type-help-text") @resource.facilitator.name "."}}>
                 <Select
                     class="w-full"
@@ -82,6 +98,7 @@
             </InputGroup>
         {{/if}}
 
+        {{#if this.show.driver}}
         <InputGroup @name={{t "order.fields.assign-driver"}} @helpText={{t "order.fields.assign-driver-help-text"}}>
             <ModelSelect
                 @modelName="driver"
@@ -101,7 +118,9 @@
                 <SelectOption::Driver @option={{model}} />
             </ModelSelect>
         </InputGroup>
+        {{/if}}
 
+        {{#if this.show.vehicle}}
         <InputGroup @name={{t "order.fields.assign-vehicle"}} @helpText={{t "order.fields.assign-vehicle-help-text"}}>
             <ModelSelect
                 @modelName="vehicle"
@@ -120,8 +139,9 @@
                 <SelectOption::Vehicle @option={{model}} />
             </ModelSelect>
         </InputGroup>
+        {{/if}}
 
-        {{#if (and @resource.pod_required (not @resource.facilitator.isIntegratedVendor))}}
+        {{#if (and this.show.pod @resource.pod_required (not @resource.facilitator.isIntegratedVendor))}}
             <InputGroup @name={{t "order.fields.proof-delivery"}} @helpText={{t "order.fields.proof-delivery-help-text"}} @required={{true}}>
                 <div class="fleetbase-model-select fleetbase-power-select ember-model-select">
                     <PowerSelect
@@ -142,7 +162,7 @@
             </InputGroup>
         {{/if}}
 
-        {{#if @resource.adhoc}}
+        {{#if (and this.show.adhoc @resource.adhoc)}}
             <div>
                 <InputGroup
                     @name={{t "order.fields.adhoc-ping"}}
@@ -158,6 +178,7 @@
             </div>
         {{/if}}
 
+        {{#if this.show.adhoc}}
         <div class="lg:col-span-2">
             <InputGroup @wrapperClass="pt-2">
                 <Toggle
@@ -170,7 +191,9 @@
                 />
             </InputGroup>
         </div>
+        {{/if}}
 
+        {{#if this.show.dispatch}}
         <div class="lg:col-span-2">
             <InputGroup @wrapperClass="pt-1">
                 <Toggle
@@ -183,7 +206,9 @@
                 />
             </InputGroup>
         </div>
+        {{/if}}
 
+        {{#if this.show.pod}}
         <div class="lg:col-span-2">
             <InputGroup @wrapperClass="pt-1">
                 <Toggle
@@ -196,6 +221,7 @@
                 />
             </InputGroup>
         </div>
+        {{/if}}
 
         <RegistryYield @registry="fleet-ops:component:order:form:details" as |RegistryComponent|>
             <RegistryComponent @order={{@resource}} @resource={{@resource}} />
diff --git a/addon/components/order/form/details.js b/addon/components/order/form/details.js
index 84ffdcda2..2a56f8ef0 100644
--- a/addon/components/order/form/details.js
+++ b/addon/components/order/form/details.js
@@ -13,6 +13,7 @@ export default class OrderFormDetailsComponent extends Component {
     @service leafletMapManager;
     @service leafletLayerVisibilityManager;
     @service currentUser;
+    @service orderPresentation;
     @tracked customFields;
 
     constructor() {
@@ -20,6 +21,40 @@ export default class OrderFormDetailsComponent extends Component {
         this.orderConfigActions.loadAll.perform();
     }
 
+    /** The presentation profile applying to the order's current config, if any. */
+    get profile() {
+        return this.orderPresentation.profileFor(this.args.resource);
+    }
+
+    /** Extension fields rendered inside the details grid when a profile applies. */
+    get profileDetailFields() {
+        return this.profile?.form?.detailFields ?? null;
+    }
+
+    /** A persisted order keeps its profiled order type; reclassification is not supported. */
+    get orderTypeLocked() {
+        return Boolean(this.profile) && this.args.resource?.isNew === false;
+    }
+
+    /** Field visibility; everything is visible unless a presentation profile hides it. */
+    get show() {
+        const hidden = this.args.hiddenFields ?? this.orderPresentation.hiddenFieldsFor(this.args.resource);
+        const visible = (key) => !hidden.includes(key);
+
+        return {
+            internalId: visible('internal-id'),
+            schedule: visible('schedule'),
+            customer: visible('customer'),
+            facilitator: visible('facilitator'),
+            serviceType: visible('service-type'),
+            driver: visible('driver'),
+            vehicle: visible('vehicle'),
+            pod: visible('pod'),
+            adhoc: visible('adhoc'),
+            dispatch: visible('dispatch'),
+        };
+    }
+
     get integratedVendorServiceType() {
         return this.args.resource?.type;
     }
@@ -38,12 +73,23 @@ export default class OrderFormDetailsComponent extends Component {
 
     @task *selectOrderConfig(orderConfig) {
         if (!orderConfig) return;
+        const previousProfile = this.orderPresentation.profileFor(this.args.resource);
         this.args.resource.setProperties({
             order_config_uuid: orderConfig.id,
             order_config: orderConfig,
             type: orderConfig.key,
         });
         this.args.resource.payload.set('type', orderConfig.key);
+
+        // Let presentation profiles clean up or prepare the draft when the order type changes.
+        const nextProfile = this.orderPresentation.profileFor(this.args.resource);
+        if (previousProfile && previousProfile !== nextProfile && typeof previousProfile.release === 'function') {
+            previousProfile.release(this.args.resource);
+        }
+        if (nextProfile && nextProfile !== previousProfile) {
+            this.orderPresentation.prepare(this.args.resource);
+        }
+
         this.requestServiceQuoteRefresh('details.order_config.changed');
 
         try {
diff --git a/addon/components/order/form/route.hbs b/addon/components/order/form/route.hbs
index fb8e59a99..9fe9d95d8 100644
--- a/addon/components/order/form/route.hbs
+++ b/addon/components/order/form/route.hbs
@@ -1,7 +1,9 @@
-<ContentPanel @title={{t "order.fields.route"}} @open={{true}} @wrapperClass="bordered-top">
+<ContentPanel @title={{or this.profileTitle (t "order.fields.route")}} @open={{true}} @wrapperClass="bordered-top">
     <div class="flex flex-row items-center justify-between mb-4">
         <div class="flex">
-            <Toggle @isToggled={{this.multipleWaypoints}} @onToggle={{this.toggleWaypoints}} @label={{t "order.fields.route-label"}} />
+            {{#if this.allowsMultipleWaypoints}}
+                <Toggle @isToggled={{this.multipleWaypoints}} @onToggle={{this.toggleWaypoints}} @label={{t "order.fields.route-label"}} />
+            {{/if}}
         </div>
         <div class="flex flex-1 justify-end space-x-2">
             {{#if this.multipleWaypoints}}
diff --git a/addon/components/order/form/route.js b/addon/components/order/form/route.js
index f95f3f793..9666fe988 100644
--- a/addon/components/order/form/route.js
+++ b/addon/components/order/form/route.js
@@ -22,6 +22,7 @@ export default class OrderFormRouteComponent extends Component {
     @service notifications;
     @service placeActions;
     @service orderCreation;
+    @service orderPresentation;
     @tracked multipleWaypoints = false;
     @tracked routingControl;
     @tracked route;
@@ -35,6 +36,16 @@ export default class OrderFormRouteComponent extends Component {
         }
     }
 
+    /** A presentation profile may hide multi-drop routing and rename the route panel. */
+    get allowsMultipleWaypoints() {
+        const hidden = this.args.hiddenFields ?? this.orderPresentation.hiddenFieldsFor(this.args.resource);
+        return !hidden.includes('multiple-waypoints');
+    }
+
+    get profileTitle() {
+        return this.orderPresentation.profileFor(this.args.resource)?.form?.titles?.route ?? null;
+    }
+
     get coordinates() {
         return this.routePoints.map(({ place }) => [place.latitude, place.longitude]);
     }
diff --git a/addon/components/order/kanban.js b/addon/components/order/kanban.js
index d6b84a7ff..04e4accf6 100644
--- a/addon/components/order/kanban.js
+++ b/addon/components/order/kanban.js
@@ -13,7 +13,9 @@ export default class OrderKanbanComponent extends Component {
     @service fetch;
     @service notifications;
     @service intl;
+    @service store;
     @tracked statuses = [];
+    @tracked orderConfigRecord = null;
     @tracked orders = this.args.orders ?? [];
     @tracked orderConfig = this.args.orderConfig ?? null;
 
@@ -23,6 +25,11 @@ export default class OrderKanbanComponent extends Component {
     };
 
     get columns() {
+        const lifecycleColumns = this.#lifecycleColumns();
+        if (lifecycleColumns) {
+            return lifecycleColumns;
+        }
+
         const start = this.#defaultStatuses.start ?? [];
         const end = this.#defaultStatuses.end ?? [];
         const loaded = isArray(this.statuses) ? this.statuses : [];
@@ -112,6 +119,64 @@ export default class OrderKanbanComponent extends Component {
         this.loadStatuses.perform();
     }
 
+    /**
+     * Columns for an order config with a configured lifecycle (`meta.lifecycle`): the flow's own
+     * activities in graph order from the initial activity, titled with their status labels.
+     * No default dispatch columns are injected. Returns null for configs without a lifecycle.
+     */
+    #lifecycleColumns() {
+        const config = this.orderConfigRecord;
+        const lifecycle = config?.meta?.lifecycle;
+        const flow = config?.flow;
+        if (!lifecycle || !flow || typeof flow !== 'object') {
+            return null;
+        }
+
+        const activities = Object.values(flow).filter((activity) => activity && activity.code);
+        const byKeyOrCode = new Map();
+        for (const activity of activities) {
+            byKeyOrCode.set(activity.key ?? activity.code, activity);
+            byKeyOrCode.set(activity.code, activity);
+        }
+
+        // Breadth-first walk from the initial activity, then any activities not reachable from it.
+        const ordered = [];
+        const seen = new Set();
+        const queue = [byKeyOrCode.get(lifecycle.initial)].filter(Boolean);
+        while (queue.length) {
+            const activity = queue.shift();
+            if (seen.has(activity.code)) continue;
+            seen.add(activity.code);
+            ordered.push(activity);
+            for (const child of activity.activities ?? []) {
+                const next = byKeyOrCode.get(typeof child === 'string' ? child : (child?.key ?? child?.code));
+                if (next && !seen.has(next.code)) queue.push(next);
+            }
+        }
+        for (const activity of activities.sort((a, b) => (a.sequence ?? 0) - (b.sequence ?? 0))) {
+            if (!seen.has(activity.code)) {
+                seen.add(activity.code);
+                ordered.push(activity);
+            }
+        }
+
+        // Keep orders whose status is not part of the flow visible rather than silently dropping them.
+        const columns = ordered.map((activity) => ({ id: activity.code, title: this.#activityTitle(activity) }));
+        for (const status of isArray(this.statuses) ? this.statuses : []) {
+            if (status && !seen.has(status)) {
+                seen.add(status);
+                columns.push({ id: status, title: titleize(smartHumanize(status)) });
+            }
+        }
+
+        return columns.map((column, index) => ({ ...column, position: index, cards: this.#getOrdersByStatus(column.id, this.orders) }));
+    }
+
+    #activityTitle(activity) {
+        const label = typeof activity.status === 'string' ? activity.status.trim() : '';
+        return label && !label.includes('{') ? label : titleize(smartHumanize(activity.code));
+    }
+
     #getOrdersByStatus(status, orders = []) {
         let filteredOrders = orders.filter((order) => order.status === status);
         if (this.orderConfig) {
@@ -125,6 +190,13 @@ export default class OrderKanbanComponent extends Component {
         const params = {};
         if (this.orderConfig) params.order_config_uuid = this.orderConfig;
 
+        try {
+            this.orderConfigRecord = this.orderConfig ? yield this.store.findRecord('order-config', this.orderConfig) : null;
+        } catch (err) {
+            this.orderConfigRecord = null;
+            debug('Unable to load order config for board: ' + err.message);
+        }
+
         try {
             const statuses = yield this.fetch.get('orders/statuses', params);
             this.statuses = isArray(statuses) ? statuses : [];
diff --git a/addon/controllers/operations/orders/index.js b/addon/controllers/operations/orders/index.js
index c18379903..e857d7158 100644
--- a/addon/controllers/operations/orders/index.js
+++ b/addon/controllers/operations/orders/index.js
@@ -7,6 +7,7 @@ import relationValue from '../../../utils/relation-value';
 
 export default class OperationsOrdersIndexController extends Controller {
     @service orderActions;
+    @service orderPresentation;
     @service driverActions;
     @service vehicleActions;
     @service store;
@@ -436,7 +437,7 @@ export default class OperationsOrdersIndexController extends Controller {
                 wrapperClass: 'flex items-center justify-end mx-2',
                 sticky: 'right',
                 width: 60,
-                actions: [
+                actions: this.withPresentationProfile([
                     {
                         id: 'view',
                         label: this.intl.t('common.view-resource', { resource: this.intl.t('resource.order') }),
@@ -485,7 +486,7 @@ export default class OperationsOrdersIndexController extends Controller {
                         fn: this.orderActions.delete,
                         permission: 'fleet-ops delete order',
                     },
-                ],
+                ]),
                 sortable: false,
                 filterable: false,
                 resizable: false,
@@ -494,6 +495,25 @@ export default class OperationsOrdersIndexController extends Controller {
         ];
     }
 
+    /**
+     * Hides the row actions an order's presentation profile lists in `hidden.actions`, by id,
+     * the same way the details panel does.
+     */
+    withPresentationProfile(actions) {
+        return actions.map((item) => {
+            if (!item.id) {
+                return item;
+            }
+
+            const isVisible = item.isVisible;
+            const builtInVisible = (order, ...rest) => (typeof isVisible === 'function' ? isVisible(order, ...rest) : isVisible !== false);
+            return {
+                ...item,
+                isVisible: (order, ...rest) => !this.orderPresentation.isHidden(order, 'actions', item.id) && builtInVisible(order, ...rest),
+            };
+        });
+    }
+
     constructor() {
         super(...arguments);
         this.orderSocketEvents.startCompany();
diff --git a/addon/controllers/operations/orders/index/details.js b/addon/controllers/operations/orders/index/details.js
index e7f8a0dcf..327623dfe 100644
--- a/addon/controllers/operations/orders/index/details.js
+++ b/addon/controllers/operations/orders/index/details.js
@@ -17,6 +17,7 @@ export default class OperationsOrdersIndexDetailsController extends Controller {
     @service hostRouter;
     @service universe;
     @service sidebar;
+    @service orderPresentation;
     @service abilities;
     @tracked routingControl;
     @tracked routingCompleted = false;
@@ -84,7 +85,22 @@ export default class OperationsOrdersIndexDetailsController extends Controller {
         ];
     }
 
+    /** True when the order reached a terminal activity (default or configured lifecycle). */
+    get isClosed() {
+        const status = this.model.status;
+        const lifecycle = this.model.order_config?.meta?.lifecycle;
+        if (!lifecycle) {
+            return status === 'canceled';
+        }
+
+        // Matches OrderConfig::getTerminalActivityCodes(): `terminal` plus the configured completed and canceled codes.
+        const terminal = [...(Array.isArray(lifecycle.terminal) ? lifecycle.terminal : []), lifecycle.completed, lifecycle.canceled].filter(Boolean);
+        return status === 'canceled' || terminal.includes(status);
+    }
+
     get actionButtons() {
+        const isHidden = (id) => this.orderPresentation.isHidden(this.model, 'actions', id);
+
         return [
             {
                 items: [
@@ -92,22 +108,23 @@ export default class OperationsOrdersIndexDetailsController extends Controller {
                         id: 'edit-order-details',
                         text: 'Edit details',
                         icon: 'pencil',
+                        disabled: this.isClosed,
                         permission: 'fleet-ops update order',
-                        disabled: this.model.status === 'canceled',
                         fn: () => this.orderActions.editOrderDetails(this.model),
                     },
                     {
                         id: 'update-activity',
                         text: 'Update activity',
                         icon: 'signal',
+                        disabled: this.isClosed,
                         permission: 'fleet-ops update order',
-                        disabled: this.model.status === 'canceled',
                         fn: () =>
                             this.orderActions.updateActivity(this.model, {
                                 onFinish: this.handleActivityModalFinish,
                             }),
                     },
                     {
+                        id: this.model.has_driver_assigned ? 'unassign-driver' : 'assign-driver',
                         text: this.model.has_driver_assigned ? 'Unassign driver' : 'Assign driver',
                         icon: this.model.has_driver_assigned ? 'user-xmark' : 'edit',
                         permission: 'fleet-ops assign-driver-for order',
@@ -144,8 +161,8 @@ export default class OperationsOrdersIndexDetailsController extends Controller {
                         text: 'Cancel order',
                         icon: 'ban',
                         class: 'text-danger',
+                        disabled: this.isClosed,
                         permission: 'fleet-ops cancel order',
-                        disabled: this.model.status === 'canceled',
                         fn: () => this.orderActions.cancel(this.model),
                     },
                     {
@@ -163,7 +180,10 @@ export default class OperationsOrdersIndexDetailsController extends Controller {
                                 },
                             }),
                     },
-                ].filter(Boolean),
+                ]
+                    .filter(Boolean)
+                    .filter((item) => !item.id || !isHidden(item.id))
+                    .filter((item, index, items) => !(item.separator && (index === 0 || items[index - 1]?.separator))),
             },
         ].map((actionButton) => ({ ...actionButton, items: this.permittedMenuItems(actionButton.items) }));
     }
diff --git a/addon/services/order-actions.js b/addon/services/order-actions.js
index 9abfb9d54..32ad7365b 100644
--- a/addon/services/order-actions.js
+++ b/addon/services/order-actions.js
@@ -6,6 +6,7 @@ import { task } from 'ember-concurrency';
 
 export default class OrderActionsService extends ResourceActionService {
     @service store;
+    @service orderPresentation;
     modelNamePath = 'tracking';
 
     constructor() {
@@ -314,6 +315,11 @@ export default class OrderActionsService extends ResourceActionService {
     @action editOrderDetails(order, options = {}) {
         options = options === null ? {} : options;
 
+        // Orders with a presentation profile are edited in the profiled order form, not the fixed modal.
+        if (this.orderPresentation.profileFor(order)) {
+            return this.panel.edit(order, options);
+        }
+
         this.modalsManager.show('modals/order-form', {
             title: this.intl.t('order.actions.edit-order-details'),
             acceptButtonText: this.intl.t('common.save-changes'),
diff --git a/addon/services/order-presentation.js b/addon/services/order-presentation.js
new file mode 100644
index 000000000..f091b0504
--- /dev/null
+++ b/addon/services/order-presentation.js
@@ -0,0 +1,129 @@
+import Service, { inject as service } from '@ember/service';
+import { isArray } from '@ember/array';
+
+/**
+ * Resolves an extension-owned presentation profile for an order.
+ *
+ * A profile lets an extension compose the order form, details and actions for orders
+ * whose Order Config opts in via `order_config.meta.presentation_profile`. When no
+ * profile applies every consumer renders the standard Fleet-Ops presentation.
+ *
+ * Extensions register profiles through the registry service so registration does not
+ * depend on the Fleet-Ops engine having loaded:
+ *
+ *   registryService.register('fleet-ops:order-presentation', 'profiles', 'my-profile', {
+ *       id: 'my-profile',
+ *       isEnabled() { return true; },
+ *       form: { sections: ['details', 'route', new ExtensionComponent('@org/engine', 'my-section'), 'notes'] },
+ *       details: { sections: [...] },
+ *       hidden: { fields: ['driver', 'dispatch'], actions: ['dispatch', 'assign-driver'] },
+ *       prepare(order) {},
+ *   });
+ *
+ * Native section names — form: details, route, payload, service-rate, notes, documents,
+ * orchestrator-constraints, metadata, custom-fields. Details: activity, detail, custom-fields,
+ * purchase-rate, tracking, proof, notes, integrated-vendor-details, route, payload,
+ * documents, comments, metadata.
+ *
+ * `hidden.actions` takes built-in action ids, the same ids the order table and details use in
+ * the resource view registries: dispatch, assign-driver, unassign-driver, edit-order-details,
+ * update-activity, view-label, listen-to-socket-channel, view-metadata, cancel, delete.
+ */
+export const ORDER_PRESENTATION_REGISTRY = 'fleet-ops:order-presentation';
+
+export default class OrderPresentationService extends Service {
+    @service('universe/registry-service') registryService;
+
+    get profiles() {
+        return this.registryService.getRegistry(ORDER_PRESENTATION_REGISTRY, 'profiles') ?? [];
+    }
+
+    /**
+     * Returns the presentation profile applying to an order or order config, or null.
+     *
+     * @param {Object} orderOrConfig an order (with `order_config`) or an order-config
+     * @returns {Object|null}
+     */
+    profileFor(orderOrConfig) {
+        const orderConfig = this.#resolveOrderConfig(orderOrConfig);
+        const profileId = orderConfig?.meta?.presentation_profile;
+        if (!profileId) {
+            return null;
+        }
+
+        const profile = this.profiles.find((candidate) => candidate?.id === profileId);
+        if (!profile) {
+            return null;
+        }
+
+        if (typeof profile.isEnabled === 'function' && profile.isEnabled(orderConfig) !== true) {
+            return null;
+        }
+
+        return profile;
+    }
+
+    /**
+     * Returns the ordered sections of a profile surface ("form" or "details").
+     */
+    sectionsFor(profile, surface) {
+        const sections = profile?.[surface]?.sections;
+        return isArray(sections) ? sections : [];
+    }
+
+    /**
+     * Returns renderable section descriptors for a surface ("form" or "details").
+     * Native sections resolve to `order/<surface>/<name>`; anything else is an ExtensionComponent.
+     */
+    renderableSectionsFor(profile, surface) {
+        return this.sectionsFor(profile, surface).map((section, index) => {
+            if (typeof section === 'string') {
+                return { key: `native:${section}`, native: true, name: section, componentName: `order/${surface}/${section}` };
+            }
+
+            return { key: `extension:${section?.path ?? section?.name ?? index}`, native: false, component: section };
+        });
+    }
+
+    /**
+     * Determines if a field or action is hidden by the profile applying to the subject.
+     *
+     * @param {Object} orderOrConfig
+     * @param {String} group "fields" or "actions"
+     * @param {String} key a field key, or a built-in action id
+     */
+    isHidden(orderOrConfig, group, key) {
+        const profile = this.profileFor(orderOrConfig);
+        const hidden = profile?.hidden?.[group];
+        return isArray(hidden) && hidden.includes(key);
+    }
+
+    hiddenFieldsFor(orderOrConfig) {
+        const hidden = this.profileFor(orderOrConfig)?.hidden?.fields;
+        return isArray(hidden) ? hidden : [];
+    }
+
+    /**
+     * Lets the profile normalize an order when it starts to apply (e.g. clear dispatch-only values).
+     */
+    prepare(order) {
+        const profile = this.profileFor(order);
+        if (profile && typeof profile.prepare === 'function') {
+            profile.prepare(order);
+        }
+        return profile;
+    }
+
+    #resolveOrderConfig(orderOrConfig) {
+        if (!orderOrConfig) {
+            return null;
+        }
+
+        // An order-config has a flow; an order references its config.
+        if (orderOrConfig.flow !== undefined && orderOrConfig.order_config === undefined) {
+            return orderOrConfig;
+        }
+
+        return orderOrConfig.order_config ?? null;
+    }
+}
diff --git a/addon/utils/normalize-order-config-flow.js b/addon/utils/normalize-order-config-flow.js
index c54479362..5fbda66d9 100644
--- a/addon/utils/normalize-order-config-flow.js
+++ b/addon/utils/normalize-order-config-flow.js
@@ -1,6 +1,11 @@
 import { isArray } from '@ember/array';
 
-export function getOrderConfigFlowRootCode(flow = {}) {
+export function getOrderConfigFlowRootCode(flow = {}, initialCode = null) {
+    // A configured lifecycle (`meta.lifecycle.initial`) names its own root activity.
+    if (initialCode && flow[initialCode]) {
+        return initialCode;
+    }
+
     if (flow.created) {
         return 'created';
     }
diff --git a/app/services/order-presentation.js b/app/services/order-presentation.js
new file mode 100644
index 000000000..6483885a1
--- /dev/null
+++ b/app/services/order-presentation.js
@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/services/order-presentation';
diff --git a/server/src/Http/Controllers/Internal/v1/OrderController.php b/server/src/Http/Controllers/Internal/v1/OrderController.php
index 32b762c42..4ad6b05d3 100644
--- a/server/src/Http/Controllers/Internal/v1/OrderController.php
+++ b/server/src/Http/Controllers/Internal/v1/OrderController.php
@@ -163,8 +163,15 @@ function ($request, &$input) {
                         $input['type'] = 'transport';
                     }
 
+                    // a configured lifecycle always starts at its initial activity; otherwise
                     // if no status is set its default to `created`
-                    if (!isset($input['status'])) {
+                    if ($resolvedOrderConfig && $resolvedOrderConfig->hasConfiguredLifecycle()) {
+                        $input['status'] = $resolvedOrderConfig->getInitialStatusCode();
+                        if (!$resolvedOrderConfig->allowsDispatch()) {
+                            $input['dispatched'] = false;
+                            $input['adhoc']      = false;
+                        }
+                    } elseif (!isset($input['status'])) {
                         $input['status'] = 'created';
                     }
 
@@ -185,11 +192,13 @@ function (&$request, Order &$order, &$requestInput) {
                     $entities            = Utils::get($input, 'payload.entities');
                     $uploads             = Utils::get($input, 'files', []);
                     $customFieldValues   = Utils::get($input, 'custom_field_values', []);
+                    $orderConfig         = $order->config();
+                    $hasLifecycle        = $orderConfig && $orderConfig->hasConfiguredLifecycle();
 
                     // save order route & payload with request input
                     $order
                         ->setRoute($route)
-                        ->setStatus('created', false)
+                        ->setStatus($hasLifecycle ? $orderConfig->getInitialStatusCode() : 'created', false)
                         ->insertPayload($payload)
                         ->insertWaypoints($waypoints)
                         ->insertEntities($entities);
@@ -212,8 +221,12 @@ function (&$request, Order &$order, &$requestInput) {
                         );
                     }
 
-                    // Check dispatch flag with backward compatibility (default true)
+                    // Check dispatch flag with backward compatibility (default true).
+                    // Configs with a lifecycle that disables dispatch are never dispatched.
                     $shouldDispatch = isset($input['dispatched']) ? (bool) $input['dispatched'] : true;
+                    if ($hasLifecycle && !$orderConfig->allowsDispatch()) {
+                        $shouldDispatch = false;
+                    }
 
                     // dispatch if flagged true, otherwise ensure order stays in created state
                     if ($shouldDispatch) {
@@ -483,7 +496,7 @@ public function bulkDispatch(BulkDispatchRequest $request)
         $successful = [];
 
         foreach ($orders as $order) {
-            if ($order->status !== 'created') {
+            if ($order->status !== 'created' || $order->config()?->allowsDispatch() === false) {
                 $failed[] = $order->uuid;
                 continue;
             }
@@ -615,6 +628,10 @@ public function dispatchOrder(Request $request)
             return $this->errorResponse('No order config found for dispatch.');
         }
 
+        if (!$order->config()->allowsDispatch()) {
+            return $this->errorResponse('Orders of this type are not dispatched.');
+        }
+
         if (!$order->hasDriverAssigned && !$order->adhoc) {
             return $this->errorResponse('No driver assigned to dispatch!');
         }
@@ -900,6 +917,19 @@ public function updateActivity(string $id, Request $request)
         $activity    = $request->array('activity');
         $activity    = new Activity($activity, $order->getConfigFlow());
 
+        // Configs with strict transitions only accept a configured child of the current
+        // activity, and the server-side activity definition replaces the client payload.
+        $orderConfig = $order->config();
+        if ($orderConfig && $orderConfig->hasStrictTransitions()) {
+            $targetCode = $activity->get('code');
+            $configured = $targetCode ? $orderConfig->getActivityByCode($targetCode) : null;
+            if (!$configured || !$orderConfig->canTransition($order->status, $targetCode)) {
+                return response()->error('This activity is not a permitted next step for the order.', 422);
+            }
+
+            $activity = $configured;
+        }
+
         $requiresProof = Utils::isActivity($activity)
             && ($activity->get('require_pod') || ($activity->completesOrder() && $order->pod_required));
         if ($requiresProof && !$proof && !$bypassProof) {
diff --git a/server/src/Models/Order.php b/server/src/Models/Order.php
index 7f322db80..3ff12ef87 100644
--- a/server/src/Models/Order.php
+++ b/server/src/Models/Order.php
@@ -1346,10 +1346,11 @@ public function firstDispatchWithActivity(): Order
      */
     public function cancel()
     {
-        $this->status = 'canceled';
-
+        // The canceled activity comes from the order config, which may define its own code.
         $this->loadMissing('orderConfig');
-        $canceledActivity = $this->orderConfig->getCanceledActivity();
+        $orderConfig      = $this->orderConfig ?? $this->config();
+        $canceledActivity = $orderConfig->getCanceledActivity();
+        $this->status     = $canceledActivity->code ?? 'canceled';
         $this->updateActivity($canceledActivity);
 
         if ($this->isIntegratedVendorOrder()) {
@@ -1783,6 +1784,37 @@ public function getAdhocPingDistance(): int
         return (int) Utils::get($this, 'adhoc_distance', Utils::get($this, 'company.options.fleetops.adhoc_distance', 6000));
     }
 
+    /**
+     * Returns the initial tracking status for a newly created order.
+     *
+     * Used by the tracking number on creation. Orders whose config defines its own
+     * lifecycle start at the configured initial activity instead of `created`.
+     *
+     * @return array|null ['code', 'status', 'details'] or null to use the default created status
+     */
+    public function getInitialTrackingStatus(): ?array
+    {
+        if (!$this->order_config_uuid) {
+            return null;
+        }
+
+        $orderConfig = OrderConfig::where('uuid', $this->order_config_uuid)->first();
+        if (!$orderConfig || !$orderConfig->hasConfiguredLifecycle()) {
+            return null;
+        }
+
+        $activity = $orderConfig->getInitialActivity();
+        if (!$activity) {
+            return null;
+        }
+
+        return [
+            'code'    => $activity->code,
+            'status'  => $this->resolveActivityTemplateString((string) $activity->get('status', '')),
+            'details' => $this->resolveActivityTemplateString((string) $activity->get('details', '')),
+        ];
+    }
+
     /**
      * Retrieves the OrderConfig associated with this order.
      *
diff --git a/server/src/Models/OrderConfig.php b/server/src/Models/OrderConfig.php
index 1c4c4193b..32d074d30 100644
--- a/server/src/Models/OrderConfig.php
+++ b/server/src/Models/OrderConfig.php
@@ -380,6 +380,125 @@ public function getActivityByCode(string $code): ?Activity
         return $this->activities()->firstWhere('code', $code);
     }
 
+    /**
+     * Returns the configured lifecycle semantics stored under `meta.lifecycle`.
+     *
+     * A configured lifecycle is opt-in. When absent the default dispatch lifecycle
+     * (created -> dispatched -> ... -> completed / canceled) applies unchanged.
+     *
+     * Supported keys:
+     * - `initial` (string)            activity code new orders start at
+     * - `completed` (string)          activity code that completes an order
+     * - `canceled` (string)           activity code used when an order is canceled
+     * - `terminal` (string[])         activity codes after which no transition is allowed
+     * - `dispatch` (bool)             false disables dispatch for orders using this config
+     * - `strict_transitions` (bool)   true only allows moving to a configured child activity
+     */
+    public function lifecycle(): array
+    {
+        $lifecycle = data_get($this->meta, 'lifecycle');
+
+        return is_array($lifecycle) ? $lifecycle : [];
+    }
+
+    /**
+     * Determines if this config defines its own lifecycle semantics.
+     */
+    public function hasConfiguredLifecycle(): bool
+    {
+        return !empty($this->lifecycle());
+    }
+
+    /**
+     * Returns the activity new orders using this config start at.
+     *
+     * Without a configured lifecycle this is the `created` activity, if present in the flow.
+     */
+    public function getInitialActivity(): ?Activity
+    {
+        $initialCode = data_get($this->lifecycle(), 'initial');
+        if ($initialCode) {
+            return $this->getActivityByCode($initialCode);
+        }
+
+        return $this->getCreatedActivity();
+    }
+
+    /**
+     * Returns the status code new orders using this config start at.
+     */
+    public function getInitialStatusCode(): string
+    {
+        return data_get($this->lifecycle(), 'initial') ?: 'created';
+    }
+
+    /**
+     * Determines if orders using this config may be dispatched.
+     */
+    public function allowsDispatch(): bool
+    {
+        $dispatch = data_get($this->lifecycle(), 'dispatch', true);
+
+        return !in_array($dispatch, [false, 'false', 0, '0'], true);
+    }
+
+    /**
+     * Determines if activity updates must follow the configured flow graph.
+     */
+    public function hasStrictTransitions(): bool
+    {
+        return (bool) data_get($this->lifecycle(), 'strict_transitions', false);
+    }
+
+    /**
+     * Returns the terminal activity codes of this config.
+     */
+    public function getTerminalActivityCodes(): array
+    {
+        if (!$this->hasConfiguredLifecycle()) {
+            return ['completed', 'canceled'];
+        }
+
+        $terminal = data_get($this->lifecycle(), 'terminal', []);
+        $terminal = is_array($terminal) ? $terminal : [];
+        foreach (['completed', 'canceled'] as $semantic) {
+            $code = data_get($this->lifecycle(), $semantic);
+            if ($code) {
+                $terminal[] = $code;
+            }
+        }
+
+        return array_values(array_unique($terminal));
+    }
+
+    /**
+     * Determines if the given activity code is terminal for this config.
+     */
+    public function isTerminalActivityCode(?string $code): bool
+    {
+        return $code !== null && in_array($code, $this->getTerminalActivityCodes(), true);
+    }
+
+    /**
+     * Determines if the configured flow permits moving from one activity code to another.
+     *
+     * Only the configured graph is consulted: the target must be listed as a child of the
+     * source activity, and terminal activities permit no further transition.
+     */
+    public function canTransition(?string $fromCode, string $toCode): bool
+    {
+        if ($fromCode === null || $this->isTerminalActivityCode($fromCode)) {
+            return false;
+        }
+
+        $from = $this->getActivityByCode($fromCode);
+        if (!$from) {
+            return false;
+        }
+
+        return $from->children()->contains(fn ($activity) => $activity->code === $toCode);
+    }
+
     /**
      * Creates an Activity instance representing a canceled order.
      *
@@ -391,6 +510,11 @@ public function getActivityByCode(string $code): ?Activity
      */
     public function getCanceledActivity()
     {
+        $configuredCode = data_get($this->lifecycle(), 'canceled');
+        if ($configuredCode && ($configuredActivity = $this->getActivityByCode($configuredCode))) {
+            return $configuredActivity;
+        }
+
         $canceledActivity = $this->activities()->firstWhere('code', 'canceled');
         if ($canceledActivity) {
             return $canceledActivity;
@@ -416,6 +540,11 @@ public function getCanceledActivity()
      */
     public function getCompletedActivity()
     {
+        $configuredCode = data_get($this->lifecycle(), 'completed');
+        if ($configuredCode && ($configuredActivity = $this->getActivityByCode($configuredCode))) {
+            return $configuredActivity;
+        }
+
         $completedActivity = $this->activities()->firstWhere('code', 'completed');
         if ($completedActivity) {
             return $completedActivity;
diff --git a/server/src/Models/TrackingNumber.php b/server/src/Models/TrackingNumber.php
index f20f62762..e5b78defd 100644
--- a/server/src/Models/TrackingNumber.php
+++ b/server/src/Models/TrackingNumber.php
@@ -291,13 +291,17 @@ public static function insertGetUuid($values = [], ?Model $owner = null)
 
         $ownerTypeName = class_basename($values['owner_type']);
 
+        // owners may define their own initial status (e.g. orders with a configured lifecycle)
+        $initialStatus = $owner && method_exists($owner, 'getInitialTrackingStatus') ? $owner->getInitialTrackingStatus() : null;
+        $initialCode   = is_array($initialStatus) && !empty($initialStatus['code']) ? $initialStatus['code'] : null;
+
         // create initial status
         $trackingStatusId = static::createInitialTrackingStatus([
             'tracking_number_uuid' => $uuid,
-            'status'               => Str::title($ownerTypeName . ' created'),
-            'details'              => 'New ' . Str::lower($ownerTypeName) . ' created.',
+            'status'               => $initialCode ? $initialStatus['status'] : Str::title($ownerTypeName . ' created'),
+            'details'              => $initialCode ? $initialStatus['details'] : 'New ' . Str::lower($ownerTypeName) . ' created.',
             'location'             => $values['location'] ?? Utils::parsePointToWkt(new Point(0, 0)),
-            'code'                 => 'CREATED',
+            'code'                 => $initialCode ? TrackingStatus::prepareCode($initialCode) : 'CREATED',
         ]);
 
         // update status of tracking number
@@ -309,7 +313,7 @@ public static function insertGetUuid($values = [], ?Model $owner = null)
             // $model->update([ 'status' => 'created' ]);
 
             // silent update
-            static::updateOwnerStatusColumn($owner, 'created');
+            static::updateOwnerStatusColumn($owner, $initialCode ?? 'created');
         }
 
         return $uuid;
diff --git a/server/tests/Feature/Http/Internal/OrderControllerActivityFlowsTest.php b/server/tests/Feature/Http/Internal/OrderControllerActivityFlowsTest.php
index 32456b9fc..8414272bd 100644
--- a/server/tests/Feature/Http/Internal/OrderControllerActivityFlowsTest.php
+++ b/server/tests/Feature/Http/Internal/OrderControllerActivityFlowsTest.php
@@ -661,3 +661,75 @@ public function __call($method, $arguments)
     $noConfig = $controller->nextActivity('order_internal', Request::create('/x', 'GET'));
     expect($noConfig->getData(true)['error'] ?? '')->toBe('No order config found for order.');
 });
+
+function fleetopsInternalActivityUseLifecycle(SQLiteConnection $connection, array $lifecycle = []): void
+{
+    $activity = fn (string $code, array $children = []) => ['key' => $code, 'code' => $code, 'status' => ucfirst($code), 'details' => ucfirst($code) . ' loan', 'activities' => $children, 'logic' => [], 'events' => [], 'complete' => $code === 'completed'];
+
+    $connection->table('order_configs')->where('uuid', 'config-1')->update([
+        'flow' => json_encode([
+            'requested' => $activity('requested', ['assigned', 'cancelled']),
+            'assigned'  => $activity('assigned', ['completed']),
+            'completed' => $activity('completed'),
+            'cancelled' => $activity('cancelled'),
+        ]),
+        'meta' => json_encode(['lifecycle' => array_replace([
+            'initial'            => 'requested',
+            'completed'          => 'completed',
+            'canceled'           => 'cancelled',
+            'dispatch'           => false,
+            'strict_transitions' => true,
+        ], $lifecycle)]),
+    ]);
+}
+
+test('strict transitions reject activities outside the configured flow and use the configured definition', function () {
+    $connection = fleetopsInternalActivityBoot();
+    $controller = new OrderController();
+
+    fleetopsInternalActivityUseLifecycle($connection);
+    fleetopsInternalActivitySeedOrder($connection, ['status' => 'requested']);
+
+    // Not a child of the current activity
+    $skipped = $controller->updateActivity('order_internal', Request::create('/x', 'POST', ['activity' => ['key' => 'completed', 'code' => 'completed', 'status' => 'Completed'], 'bypass_proof' => 1]));
+    expect($skipped->getStatusCode())->toBe(422)
+        ->and($skipped->getData(true)['error'])->toContain('not a permitted next step');
+
+    // Not in the flow at all
+    $unknown = $controller->updateActivity('order_internal', Request::create('/x', 'POST', ['activity' => ['key' => 'started', 'code' => 'started', 'status' => 'Started'], 'bypass_proof' => 1]));
+    expect($unknown->getStatusCode())->toBe(422);
+
+    // A configured child is accepted, with the server-side definition replacing the client's
+    $assigned = $controller->updateActivity('order_internal', Request::create('/x', 'POST', ['activity' => ['key' => 'assigned', 'code' => 'assigned', 'status' => 'Tampered'], 'bypass_proof' => 1]));
+    expect($assigned)->toBeInstanceOf(Fleetbase\FleetOps\Http\Resources\v1\Order::class)
+        ->and($connection->table('tracking_statuses')->where('code', 'ASSIGNED')->value('status'))->toBe('Assigned');
+});
+
+test('dispatch order refuses orders whose lifecycle disables dispatch', function () {
+    $connection = fleetopsInternalActivityBoot();
+    $controller = new OrderController();
+
+    fleetopsInternalActivityUseLifecycle($connection);
+    fleetopsInternalActivitySeedOrder($connection, ['status' => 'requested', 'driver_assigned_uuid' => 'driver-1']);
+
+    $response = $controller->dispatchOrder(Request::create('/x', 'POST', ['order' => 'order_internal']));
+    expect($response->getData(true)['error'] ?? '')->toContain('not dispatched')
+        ->and($connection->table('orders')->value('dispatched'))->toBe(0);
+});
+
+test('orders with a configured lifecycle start their tracking at the initial activity', function () {
+    $connection = fleetopsInternalActivityBoot();
+
+    // No config, or a config without a lifecycle, keeps the default created status
+    expect((new Fleetbase\FleetOps\Models\Order())->getInitialTrackingStatus())->toBeNull();
+    $order                    = new Fleetbase\FleetOps\Models\Order();
+    $order->order_config_uuid = 'config-1';
+    expect($order->getInitialTrackingStatus())->toBeNull();
+
+    fleetopsInternalActivityUseLifecycle($connection);
+    expect($order->getInitialTrackingStatus())->toBe(['code' => 'requested', 'status' => 'Requested', 'details' => 'Requested loan']);
+
+    // An initial activity missing from the flow falls back to the default
+    fleetopsInternalActivityUseLifecycle($connection, ['initial' => 'nowhere']);
+    expect($order->getInitialTrackingStatus())->toBeNull();
+});
diff --git a/server/tests/Feature/Http/Internal/OrderControllerCreateRecordTest.php b/server/tests/Feature/Http/Internal/OrderControllerCreateRecordTest.php
index 0049061ab..855ac2f52 100644
--- a/server/tests/Feature/Http/Internal/OrderControllerCreateRecordTest.php
+++ b/server/tests/Feature/Http/Internal/OrderControllerCreateRecordTest.php
@@ -486,3 +486,29 @@ public function __call($method, $arguments)
     expect($result)->toBeArray()->toHaveKey('order')
         ->and($connection->table('orders')->value('dispatched'))->not->toBeNull();
 });
+
+test('create record starts configured lifecycles at their initial activity and never dispatches them', function () {
+    $connection = fleetopsInternalOrderCreateBoot();
+    $connection->table('order_configs')->where('uuid', 'config-1')->update([
+        'flow' => json_encode([
+            'requested' => ['key' => 'requested', 'code' => 'requested', 'status' => 'Requested', 'details' => 'Loan requested', 'activities' => ['completed']],
+            'completed' => ['key' => 'completed', 'code' => 'completed', 'status' => 'Completed', 'details' => 'Loan completed', 'activities' => []],
+        ]),
+        'meta' => json_encode(['lifecycle' => ['initial' => 'requested', 'completed' => 'completed', 'dispatch' => false]]),
+    ]);
+
+    // Asks to be dispatched; the lifecycle overrides both the status and the dispatch flag
+    $result = (new OrderController())->createRecord(Request::create('/int/v1/orders', 'POST', [
+        'order' => [
+            'status'     => 'created',
+            'dispatched' => true,
+            'adhoc'      => true,
+            'payload'    => ['type' => 'transport'],
+        ],
+    ]));
+
+    expect($result)->toBeArray()->toHaveKey('order')
+        ->and($connection->table('orders')->value('status'))->toBe('requested')
+        ->and((bool) $connection->table('orders')->value('dispatched'))->toBeFalse()
+        ->and((bool) $connection->table('orders')->value('adhoc'))->toBeFalse();
+});
diff --git a/server/tests/OrderConfigLifecycleTest.php b/server/tests/OrderConfigLifecycleTest.php
new file mode 100644
index 000000000..7194b05d0
--- /dev/null
+++ b/server/tests/OrderConfigLifecycleTest.php
@@ -0,0 +1,120 @@
+<?php
+
+use Fleetbase\FleetOps\Models\OrderConfig;
+
+/**
+ * Opt-in configured lifecycles (`meta.lifecycle`): a config can define its own initial, completed,
+ * canceled and terminal activities, disable dispatch and require configured transitions, without
+ * changing the default dispatch lifecycle of configs that do not opt in.
+ */
+function lifecycleActivity(string $code, array $children = [], bool $complete = false): array
+{
+    return ['key' => $code, 'code' => $code, 'status' => ucfirst(str_replace('_', ' ', $code)), 'details' => '', 'activities' => $children, 'logic' => [], 'events' => [], 'complete' => $complete];
+}
+
+function customLifecycleConfig(array $lifecycle = []): OrderConfig
+{
+    $config = new OrderConfig();
+    $config->setRawAttributes([
+        'flow' => json_encode([
+            'requested'   => lifecycleActivity('requested', ['assigned', 'cancelled']),
+            'assigned'    => lifecycleActivity('assigned', ['handed_over', 'cancelled']),
+            'handed_over' => lifecycleActivity('handed_over', ['active']),
+            'active'      => lifecycleActivity('active', ['extended', 'returned']),
+            'extended'    => lifecycleActivity('extended', ['active']),
+            'returned'    => lifecycleActivity('returned', ['completed']),
+            'completed'   => lifecycleActivity('completed', [], true),
+            'cancelled'   => lifecycleActivity('cancelled'),
+        ]),
+        'meta' => json_encode(['lifecycle' => array_replace([
+            'initial'            => 'requested',
+            'completed'          => 'completed',
+            'canceled'           => 'cancelled',
+            'terminal'           => ['completed', 'cancelled'],
+            'dispatch'           => false,
+            'strict_transitions' => true,
+        ], $lifecycle)]),
+    ]);
+
+    return $config;
+}
+
+function defaultLifecycleConfig(): OrderConfig
+{
+    $config = new OrderConfig();
+    $config->setRawAttributes([
+        'flow' => json_encode([
+            'created'    => lifecycleActivity('created', ['dispatched']),
+            'dispatched' => lifecycleActivity('dispatched', ['started']),
+            'started'    => lifecycleActivity('started', ['completed']),
+            'completed'  => lifecycleActivity('completed', [], true),
+        ]),
+        'meta' => json_encode([]),
+    ]);
+
+    return $config;
+}
+
+test('configs without meta.lifecycle keep the default dispatch semantics', function () {
+    $config = defaultLifecycleConfig();
+
+    expect($config->hasConfiguredLifecycle())->toBeFalse()
+        ->and($config->getInitialStatusCode())->toBe('created')
+        ->and($config->allowsDispatch())->toBeTrue()
+        ->and($config->hasStrictTransitions())->toBeFalse()
+        ->and($config->getTerminalActivityCodes())->toBe(['completed', 'canceled'])
+        ->and($config->getCanceledActivity()->code)->toBe('canceled')
+        ->and($config->getInitialActivity()->code)->toBe('created');
+});
+
+test('a configured lifecycle names its own initial, cancel and completion activities', function () {
+    $config = customLifecycleConfig();
+
+    expect($config->hasConfiguredLifecycle())->toBeTrue()
+        ->and($config->getInitialStatusCode())->toBe('requested')
+        ->and($config->getInitialActivity()->code)->toBe('requested')
+        ->and($config->getCanceledActivity()->code)->toBe('cancelled')
+        ->and($config->getCompletedActivity()->code)->toBe('completed')
+        ->and($config->allowsDispatch())->toBeFalse()
+        ->and($config->hasStrictTransitions())->toBeTrue()
+        ->and($config->isTerminalActivityCode('cancelled'))->toBeTrue()
+        ->and($config->isTerminalActivityCode('canceled'))->toBeFalse();
+});
+
+test('transitions follow only the configured graph', function () {
+    $config = customLifecycleConfig();
+
+    expect($config->canTransition('requested', 'assigned'))->toBeTrue()
+        ->and($config->canTransition('handed_over', 'active'))->toBeTrue()
+        ->and($config->canTransition('active', 'extended'))->toBeTrue()
+        ->and($config->canTransition('extended', 'active'))->toBeTrue()
+        ->and($config->canTransition('returned', 'completed'))->toBeTrue()
+        // skipped or foreign steps
+        ->and($config->canTransition('requested', 'handed_over'))->toBeFalse()
+        ->and($config->canTransition('requested', 'dispatched'))->toBeFalse()
+        ->and($config->canTransition('active', 'cancelled'))->toBeFalse()
+        // terminal and unknown sources
+        ->and($config->canTransition('completed', 'requested'))->toBeFalse()
+        ->and($config->canTransition('cancelled', 'assigned'))->toBeFalse()
+        ->and($config->canTransition(null, 'requested'))->toBeFalse()
+        ->and($config->canTransition('nope', 'assigned'))->toBeFalse();
+});
+
+test('a configuration-only change (added activity) is honoured without code changes', function () {
+    $config = customLifecycleConfig();
+    $flow   = json_decode($config->getAttributes()['flow'], true);
+    $flow['active']['activities'][] = 'inspection';
+    $flow['inspection']             = lifecycleActivity('inspection', ['returned']);
+    $config->setRawAttributes(['flow' => json_encode($flow), 'meta' => $config->getAttributes()['meta']]);
+
+    expect($config->canTransition('active', 'inspection'))->toBeTrue()
+        ->and($config->canTransition('inspection', 'returned'))->toBeTrue()
+        ->and($config->canTransition('inspection', 'completed'))->toBeFalse();
+});
+
+test('dispatch can be disabled with string or numeric falsy values', function () {
+    foreach ([false, 'false', 0, '0'] as $value) {
+        expect(customLifecycleConfig(['dispatch' => $value])->allowsDispatch())->toBeFalse();
+    }
+    expect(customLifecycleConfig(['dispatch' => true])->allowsDispatch())->toBeTrue();
+});
diff --git a/tests/unit/services/order-presentation-test.js b/tests/unit/services/order-presentation-test.js
new file mode 100644
index 000000000..2efa4b16a
--- /dev/null
+++ b/tests/unit/services/order-presentation-test.js
@@ -0,0 +1,47 @@
+import { module, test } from 'qunit';
+import { setupTest } from 'dummy/tests/helpers';
+import Service from '@ember/service';
+
+class RegistryServiceStub extends Service {
+    profiles = [];
+
+    getRegistry(section, list) {
+        return section === 'fleet-ops:order-presentation' && list === 'profiles' ? this.profiles : [];
+    }
+}
+
+module('Unit | Service | order-presentation', function (hooks) {
+    setupTest(hooks);
+
+    hooks.beforeEach(function () {
+        this.owner.register('service:universe/registry-service', RegistryServiceStub);
+        this.service = this.owner.lookup('service:order-presentation');
+        this.registry = this.owner.lookup('service:universe/registry-service');
+        this.order = { order_config: { meta: { presentation_profile: 'acme' } } };
+    });
+
+    test('a profile hides actions by their built-in ids', function (assert) {
+        this.registry.profiles = [{ id: 'acme', hidden: { actions: ['dispatch', 'assign-driver', 'view-metadata'] } }];
+
+        assert.true(this.service.isHidden(this.order, 'actions', 'dispatch'));
+        assert.true(this.service.isHidden(this.order, 'actions', 'assign-driver'));
+        assert.true(this.service.isHidden(this.order, 'actions', 'view-metadata'));
+        assert.false(this.service.isHidden(this.order, 'actions', 'unassign-driver'), 'each id is hidden on its own');
+        assert.false(this.service.isHidden(this.order, 'actions', 'delete'));
+    });
+
+    test('nothing is hidden without a matching profile', function (assert) {
+        this.registry.profiles = [{ id: 'acme', hidden: { fields: ['internal-id'], actions: ['dispatch'] } }];
+
+        assert.true(this.service.isHidden(this.order, 'fields', 'internal-id'));
+        assert.false(this.service.isHidden({ order_config: { meta: {} } }, 'actions', 'dispatch'));
+        assert.false(this.service.isHidden({ order_config: { meta: { presentation_profile: 'other' } } }, 'actions', 'dispatch'));
+    });
+
+    test('a profile that is not enabled does not apply', function (assert) {
+        this.registry.profiles = [{ id: 'acme', isEnabled: () => false, hidden: { actions: ['dispatch'] } }];
+
+        assert.strictEqual(this.service.profileFor(this.order), null);
+        assert.false(this.service.isHidden(this.order, 'actions', 'dispatch'));
+    });
+});