Schlagwort: TMF645

  • TMF Open APIs – Service Qualification

    TMF Open APIs – Service Qualification

    Pragmatic Patterns Using TMF645 and Its Role in the Order Capture Lifecycle

    In the previous article on Customer Order Capture, TMF645 Service Qualification was identified as one of the four core APIs involved in translating customer intent into a valid ProductOrder. Alongside TMF620, TMF679, and TMF622, it occupies a specific and critical position in the architecture — the point at which commercial feasibility meets technical reality.

    This article examines TMF645 Service Qualification in depth: what it does, how it fits into the broader order lifecycle, how it relates to other qualification APIs, and what practical patterns emerge when it is implemented correctly in telecom BSS/OSS architectures.

    What Is Service Qualification?

    Service Qualification answers a specific operational question: can this service actually be delivered to this customer at this location with these technical constraints?

    The TM Forum TMF645 Service Qualification Management API provides a standardized interface for checking the technical feasibility of a service request before that request enters the order lifecycle. It sits upstream of order submission and downstream of commercial product selection, acting as a validation gate between intent and commitment.

    TMF645 is not about whether a customer is eligible to purchase a product — that is the domain of TMF679 Product Offering Qualification. TMF645 is about whether the underlying infrastructure, network, or platform can actually support the requested service for that specific customer context.

    Why Service Qualification Matters
    Service Qualification is the difference between selling what you offer and committing to what you can deliver. Without it, the gap between commercial intent and operational execution generates late failures, costly rework, and degraded customer experience.

    Where TMF645 Fits in the Order Lifecycle

    The order capture lifecycle follows a structured progression from product discovery to order submission. TMF645 occupies the technical feasibility stage — after commercial qualification and before ProductOrder creation.

    The TM Forum TMF645 Service Qualification Management API provides a standardized interface for checking the technical feasibility of a service request before that request enters the order lifecycle. It sits upstream of order submission and downstream of commercial product selection, acting as a validation gate between intent and commitment.
    StagePrimary APICore Responsibility
    Product DiscoveryTMF620Retrieve and browse available product offerings
    Commercial QualificationTMF679Validate customer eligibility and offer compatibility
    Technical FeasibilityTMF645Verify infrastructure and network delivery capability
    Order SubmissionTMF622Capture and submit the standardized ProductOrder

    This sequencing is deliberate and architecturally significant. If technical feasibility is checked only during service activation — downstream in the lifecycle — orders that cannot be fulfilled will have already passed through multiple processing stages. The cost of late failure is substantially higher than the cost of early qualification.

    By checking technical feasibility through TMF645 before the ProductOrder is submitted, the architecture ensures that only viable orders enter the fulfillment pipeline.

    Commercial vs. Technical Qualification: A Critical Distinction

    One of the most important architectural separations in the order capture domain is the distinction between commercial qualification and technical qualification. These two validation concerns are often conflated in legacy architectures, producing systems that are difficult to evolve and prone to inconsistency.

    TMF679 – Product Offering QualificationTMF645 – Service Qualification
    Is this customer eligible for this offer?Can the network or infrastructure deliver this service?
    Are the selected options compatible with the product?Is there capacity or coverage at the requested location?
    Does the customer’s account support this product?Are the required resources available and allocatable?
    Commercial rules and pricing constraintsInfrastructure, topology, and platform constraints
    Catalog-driven validationNetwork- and inventory-driven validation

    A customer may be fully eligible for a premium broadband offer (TMF679 qualified) but reside at an address outside the fiber coverage area (TMF645 not qualified). These are orthogonal checks that must remain independent to allow each domain to evolve without coupling.

    Anti-Pattern: Merged Qualification
    Merging commercial and technical qualification into a single validation service is a recurring anti-pattern. It couples the product catalog model to network topology, forces synchronized releases across otherwise independent domains, and makes it impossible to clearly identify why a qualification failed. Keep these concerns separate.

    What TMF645 Checks

    The scope of a TMF645 qualification check depends on the service type and operational context. Typical checks include:

    Check TypeDescription
    Address and location validationConfirms the customer’s service address is within the delivery area for the requested service
    Network coverage verificationValidates that the required network technology (fiber, cable, mobile, etc.) reaches the specified location
    Resource availabilityChecks whether required infrastructure resources — ports, bandwidth, spectrum, or capacity — are available
    Infrastructure constraintsIdentifies topology-specific limitations that may affect service parameters or options
    Technology-specific feasibilityFor services such as VoIP, IPTV, or mobile, verifies platform availability and compatibility
    Third-party or partner dependency checksFor wholesale or shared infrastructure scenarios, queries external qualification systems

    The qualification result includes not just a binary qualified or not-qualified outcome, but structured detail about the constraints encountered, the alternatives available, and any parameters that must be adjusted before order submission.

    TMF645 API Structure

    The TMF645 API supports both synchronous and asynchronous qualification patterns, reflecting the reality that some qualification checks can be resolved immediately while others require queries to external or slow systems.

    Core Resources

    ResourcePurpose
    ServiceQualificationThe primary qualification request and result object
    ServiceQualificationItemRepresents a single service within a multi-service qualification request
    QualificationResultThe outcome per qualification item: qualified, notQualified, or partiallyQualified
    AlternateServiceProposalProposed alternative configurations when the original request cannot be qualified as submitted
    ServiceabilityDateEarliest date on which the service can be delivered if not immediately available

    Qualification States

    A qualification request progresses through a defined lifecycle:

    StateMeaningCaller Response
    acknowledgedRequest received and accepted for processingRetain qualification ID; await next state
    inProgressQualification checks are executingContinue monitoring via polling or event
    doneQualification completed with a resultProcess result and proceed or adjust
    terminatedWithErrorQualification could not be completedEvaluate error and retry or escalate

    Synchronous vs. Asynchronous Execution

    TMF645 supports both execution patterns. The choice between them is not arbitrary — it should reflect the operational characteristics of the underlying qualification systems.

    Synchronous QualificationAsynchronous Qualification
    Result returned in same API call responseResult delivered via event callback or polling
    Appropriate when all checks are local and fastRequired when external systems or slow lookups are involved
    Simpler caller implementationMore complex state management required by caller
    Fragile if any downstream system is slowResilient to variable response times
    Suitable for simple address lookupsRequired for partner or wholesale qualification flows
    Design Recommendation
    Architectural Recommendation: Even when synchronous qualification is technically feasible, designing the caller (typically the BFF or order capture service) to handle asynchronous results makes the integration more resilient. A synchronous qualification that becomes slower over time due to infrastructure growth should not require a re-architecture of the calling layer.

    Qualification in the BFF and Channel Layer

    In a well-structured order capture architecture, the BFF (Backend-for-Frontend) orchestrates qualification calls on behalf of the digital channel. This keeps the frontend free from direct dependency on TMF APIs while maintaining a clean separation between engagement logic and domain validation.

    The BFF is responsible for:

    • Aggregating product selection, customer context, and location data into a qualification request
    • Calling TMF679 for commercial qualification and TMF645 for technical qualification
    • Presenting qualification results to the frontend in a channel-appropriate format
    • Blocking order submission if qualification has not succeeded
    • Surfacing alternative proposals from TMF645 if the original request cannot be qualified

    The BFF should not implement qualification logic itself. Its role is orchestration and translation — not validation. Qualification rules live behind the TMF645 interface, inside the domain that owns the qualification logic.

    Anti-Pattern: Qualification in the Channel
    A common mistake is implementing address validation or coverage checks inside the BFF or frontend layer. This creates duplicated logic, inconsistencies between channels, and tight coupling to infrastructure data that changes independently of digital channel releases. Qualification logic belongs behind TMF APIs.

    Handling Qualification Results

    The outcome of a TMF645 qualification is not always a simple pass or fail. Three result types must be handled explicitly:

    1. Qualified

    The service can be delivered as requested. The qualification result may include additional information — such as confirmed delivery dates, available service parameters, or resource identifiers — that should be carried forward into the ProductOrder payload.

    2. Not Qualified

    The service cannot be delivered as requested. The result should include structured detail on the reason for disqualification: coverage boundary, resource unavailability, platform incompatibility, or infrastructure constraint. This information should be surfaced to the customer clearly, with appropriate next steps.

    In some architectures, a not-qualified result triggers a waitlist or future-date qualification flow, where the system tracks the customer’s intent and notifies them when qualification conditions change.

    3. Partially Qualified or Alternative Proposed

    TMF645 supports the return of alternative service proposals when the requested configuration cannot be qualified but a modified version can. Alternatives may include:

    • A lower bandwidth tier where the full requested speed is not available
    • A different access technology (e.g., FTTC instead of FTTP)
    • A future delivery date when current resources are temporarily exhausted
    • A modified service area or endpoint if the exact address has limited coverage

    Alternative proposals must be presented to the customer as genuine choices, not silent fallbacks. The channel layer must handle these gracefully and allow the customer to accept, reject, or modify their selection before proceeding.

    Relationship to Order Submission via TMF622

    The output of a successful TMF645 qualification is not discarded — it informs the structure and content of the ProductOrder submitted through TMF622. Key qualification data that flows into the order includes:

    Qualification OutputRole in TMF622 ProductOrder
    Qualification IDCarried as a correlation reference in the ProductOrder for traceability
    Confirmed service parametersUsed to populate the requested characteristics of the order item
    Resource identifiersReferenced in the order to ensure the correct infrastructure is reserved
    Delivery date commitmentReflected in the requested start date of the order
    Alternative proposal referenceIncluded if the customer accepted an alternative configuration

    This linkage between qualification and order is architecturally important. It ensures that the ProductOrder reflects not just what the customer wants, but what the network has confirmed it can deliver. Orders that do not carry qualification context force downstream systems to re-check feasibility, introducing redundancy, delay, and potential inconsistency.

    Design Principle
    Design Principle: The qualification reference should be treated as a first-class attribute of the ProductOrder, not an optional annotation. Downstream decomposition and service activation systems rely on this reference to skip redundant feasibility checks and proceed directly to fulfillment.

    Caching, Validity, and Qualification Windows

    A qualification result is not indefinitely valid. Infrastructure conditions, resource availability, and coverage boundaries can change. TMF645 results should carry an explicit validity window, after which the qualification must be refreshed before order submission.

    Common validity patterns include:

    PatternDescription
    Time-bounded validityQualification result is valid for a defined period (e.g., 24–72 hours) before expiry
    Event-invalidated qualificationQualification is invalidated if specific network events occur (maintenance, topology changes)
    Commitment-based holdingFor high-demand resources, qualification results may optionally reserve capacity for a defined window
    Re-qualification on modificationAny change to the order parameters (address, service tier, options) requires a fresh qualification

    Digital channels and BFFs must enforce qualification validity. Submitting a ProductOrder against an expired qualification is a common source of late-stage failures that could have been avoided with appropriate staleness detection.

    Common Anti-Patterns in Service Qualification

    1. Qualification as an Afterthought

    Some architectures treat service qualification as an optional pre-check rather than a required gate. Orders are accepted and submitted regardless of whether qualification has been completed, relying on activation-time failure handling to catch infeasible requests.

    This pattern multiplies the cost of failure. An order that fails during activation has already consumed order management processing, inventory reservation, and orchestration capacity. An order that fails at qualification consumes only a lightweight API call.

    2. Embedding Qualification Logic in Activation

    When qualification logic is not exposed through a dedicated interface like TMF645, it tends to migrate into the activation domain, where it is evaluated at provisioning time. This delays failure detection, increases orchestration complexity, and mixes technical feasibility concerns with execution logic.

    3. Silently Accepting Alternatives

    Returning an alternative service proposal without explicit customer confirmation is a source of downstream disputes and operational confusion. If the customer ordered 1 Gbps fiber and the network can only deliver 500 Mbps FTTC, that substitution must be surfaced and confirmed — not silently applied to the order.

    4. Not Propagating Qualification Context

    Discarding the qualification reference after order submission disconnects the ProductOrder from its feasibility basis. Activation systems that cannot reference the qualification outcome are forced to repeat checks, introducing latency and creating opportunities for divergence between what was qualified and what is provisioned.

    Integration Pattern Summary

    When TMF645 is implemented correctly, it provides a clean, early validation gate that prevents infeasible orders from entering the fulfillment pipeline and ensures that downstream processing operates on committed, technically verified requests.

    ResponsibilityMechanismRationale
    Validate technical feasibility earlyTMF645 Service Qualification before TMF622 order submissionPrevents late failures and reduces orchestration complexity
    Separate commercial from technical validationTMF679 for eligibility, TMF645 for feasibility — independent callsAllows each domain to evolve independently
    Surface alternatives explicitlyReturn AlternateServiceProposal with qualification resultEnsures customer confirmation before substitution is applied
    Propagate qualification context to ordersCarry qualification ID and confirmed parameters in ProductOrderEnables activation to skip redundant checks
    Enforce qualification validity windowsTrack expiry and re-qualify if window elapses or parameters changePrevents order submission against stale feasibility data
    Keep qualification logic behind the APIValidation in the domain, not in BFF or frontendEliminates duplication and maintains consistency across channels

    What’s Next

    This article examined TMF645 Service Qualification as a standalone domain: its structure, its role in the order lifecycle, its relationship to commercial qualification via TMF679, and the practical patterns required to implement it without introducing architectural fragility.

    Together with the preceding articles in this series, the full order capture lifecycle is now covered from first product discovery through technical feasibility to order submission:

    ArticlePrimary APIsFocus
    Customer Order CaptureTMF620, TMF679, TMF645, TMF622End-to-end order capture lifecycle overview
    TMF663 Shopping Cart ManagementTMF663Pre-order cart aggregation and session management
    Service Qualification (this article)TMF645Technical feasibility validation in depth
    Customer Order ManagementTMF622, TMF641, TMF637Order decomposition and orchestration
    Service ActivationTMF641, TMF633, TMF638Technical execution and inventory management

    The next publication in the series will examine TMF620 Product Catalog Management in depth — exploring how catalog design decisions shape the complexity (or simplicity) of every downstream domain, from qualification through to activation.

    Closing Principle
    Closing Principle: Service Qualification is not a technical detail to be deferred. It is the architectural mechanism that aligns commercial commitment with operational capability. Systems that skip this step shift the cost of infeasibility downstream, where it is harder to handle, more expensive to recover from, and more visible to the customer.
  • TMF Open APIs – Customer Order Capture

    From Qualification to ProductOrder

    Telecommunication architectures often struggle not with service activation or network execution, but with the very first step of the lifecycle: translating customer intent into a clean, valid order.

    Many transformation programs introduce complexity at this stage by tightly coupling digital channels to backend systems, embedding business rules inside frontends, or overloading orchestration platforms with responsibilities that belong to domain boundaries.

    This article explores a pragmatic approach to customer order capture using TM Forum Open APIs as stable integration contracts — focusing on how commercial validation, technical feasibility, and order submission can be implemented without creating architectural bottlenecks.

    The discussion builds on the master architecture presented in TM Forum Open APIs Without the Complexity Trap and focuses specifically on the capture layer.

    Diagram 1 – Customer Order Capture Flow

    Customer Order Capture:
- TMF620 — Product Catalog Management
- TMF679 — Product Offering Qualification
- TMF645 — Service Qualification
- TMF622 — Product Ordering Management

    Architectural Scope

    This article focuses on the commercial entry point of the lifecycle — the transition from customer interaction to standardized product order submission.

    Core APIs covered:

    • TMF620 — Product Catalog Management
    • TMF679 — Product Offering Qualification
    • TMF645 — Service Qualification
    • TMF622 — Product Ordering Management

    These APIs represent the boundary between digital engagement and downstream operational domains.

    Key Architectural Principle

    TM Forum APIs should act as:

    • stable integration contracts
    • domain boundaries
    • interoperability interfaces

    They should NOT:

    • define internal data models
    • dictate orchestration logic
    • force digital channels to mirror backend complexity.

    The goal of customer order capture is simple:

    Produce a clean, validated ProductOrder representing commercial intent.

    Everything else belongs downstream.

    Engagement Layer — Digital Channel / BFF

    Customer interaction begins in digital channels:

    • Web portals
    • Mobile applications
    • Partner systems

    The BFF (Backend-for-Frontend) plays a crucial role:

    • Aggregates multiple backend APIs
    • Shields frontend from domain complexity
    • Maintains UX-specific workflows.

    However, a common anti-pattern is turning the BFF into a business logic engine.

    Pragmatic rule:

    Validation logic lives behind TMF APIs, not inside the channel.

    Product Discovery — TMF620 Product Catalog

    The lifecycle begins with browsing commercial offerings via TMF620.

    Responsibilities:

    • Retrieve product offerings
    • Resolve bundles and configurations
    • Provide structured product metadata.

    Architectural pattern:

    TMF620 often acts as an API facade over legacy catalog platforms.

    Benefits:

    • Stable contract for digital channels
    • Decoupling from catalog implementation
    • Incremental modernization possible.

    Important design choice:

    The catalog provides information — it does not validate eligibility.

    Commercial Qualification — TMF679 Product Offering Qualification

    Product Offering Qualification validates commercial constraints:

    • Customer eligibility
    • Allowed configurations
    • Offer compatibility rules.

    Typical inputs:

    • customerId
    • selected offering
    • requested characteristics.

    Typical outputs:

    • qualificationResult (qualified/notQualified)
    • validation messages
    • adjusted configuration suggestions.

    Common complexity trap:

    Embedding qualification logic inside order processing.

    Pragmatic approach:

    Qualification remains a separate validation boundary.

    This allows:

    • early failure detection
    • faster UX feedback
    • reduced orchestration complexity.

    Technical Feasibility — TMF645 Service Qualification

    One of the most important architectural separations is:

    Commercial validation ≠ Technical feasibility.

    TMF645 handles:

    • address validation
    • network coverage
    • resource availability
    • infrastructure constraints.

    Why separate?

    If technical feasibility is checked only during activation:

    • orders fail late
    • customer experience suffers
    • orchestration becomes complex.

    Using TMF645 early:

    • prevents invalid orders entering lifecycle
    • reduces downstream rework.

    Transition Boundary — TMF622 Product Ordering

    Once qualification is complete and customer confirms purchase, the digital channel submits a ProductOrder via TMF622.

    TMF622 acts as:

    The boundary between commercial intent and operational execution.

    Responsibilities:

    • Capture standardized commercial request
    • Provide initial acknowledgement
    • Hand ownership to order management domain.

    Key design goals:

    • ProductOrder payload should be minimal but complete.
    • Avoid embedding downstream execution details.

    Example conceptual structure:

    • orderItem
    • productOffering
    • customer reference
    • requested characteristics
    • relatedParty.

    Designing a Clean ProductOrder

    A pragmatic ProductOrder:

    • Represents what the customer wants, not how to execute it.

    Avoid:

    • technical resource details
    • network-specific parameters
    • service-level workflows.

    These belong to decomposition inside Order Management.

    Recommended practices:

    • include clear correlation identifiers
    • ensure idempotent submission
    • keep optional attributes truly optional.

    State Management at Capture Stage

    Typical lifecycle states after submission:

    • acknowledged
    • inProgress.

    Digital channels should:

    • rely on asynchronous updates rather than polling excessively.
    • treat TMF622 response as acceptance of intent, not completion.

    Common Anti-Patterns

    1. Fat BFF

    Embedding:

    • qualification logic
    • catalog rules
    • decomposition logic

    inside the channel layer.

    Result:

    • duplicated rules
    • inconsistent behavior.

    2. TMF-First Internal Modeling

    Designing internal microservices directly around TMF schemas.

    Result:

    • tight coupling
    • inflexible evolution.

    3. Central Workflow Engine Too Early

    Using external BPM tools to orchestrate order capture.

    Better:

    Simple capture triggers domain-owned orchestration later.

    Integration Pattern Summary

    Customer Order Capture architecture should:

    • Use TMF620 for discovery
    • Use TMF679 for commercial validation
    • Use TMF645 for technical feasibility
    • Submit via TMF622 as standardized boundary.

    This separation ensures:

    • early validation
    • cleaner orchestration downstream
    • reduced coupling.

    What’s Next

    This article focused on capturing commercial intent and producing a clean ProductOrder.

    In the next publications, we move inside the Customer Order Management domain and explore:

    • Product-to-service decomposition
    • State machines vs workflow engines
    • Asynchronous orchestration patterns
    • Handling partial fulfillment and failure scenarios
    • Updating Product Inventory (TMF637) from lifecycle events.
  • TMF Open APIs Without the Complexity Trap

    Pragmatic Integration Patterns Using TMF620, TMF679, TMF622, TMF637, TMF641, TMF633, TMF645 and TMF638

    Telecommunication architectures increasingly adopt TM Forum Open APIs to standardize integration across OSS/BSS ecosystems. These APIs provide a shared semantic language that enables interoperability between systems from different vendors and internal domains.

    However, real-world implementations often struggle — not because of the APIs themselves, but because of how they are applied architecturally. Many organizations introduce unnecessary complexity: heavy middleware layers, rigid orchestration engines, or “TMF-first” internal modeling that couples everything to standard schemas and slows delivery.

    This article presents a set of pragmatic integration prototypes demonstrating how core TM Forum APIs can be used effectively as stable integration contracts, while avoiding common complexity traps. The goal is to show an approach that is realistic for enterprise landscapes, but still incremental and maintainable.

    The prototypes focus on the following APIs:

    • TMF620 Product Catalog Management
    • TMF679 Product Offering Qualification
    • TMF622 Product Ordering Management
    • TMF637 Product Inventory Management
    • TMF641 Service Ordering Management
    • TMF633 Service Catalog Management
    • TMF645 Service Qualification Management
    • TMF638 Service Inventory Management

    Together, these APIs cover a complete lifecycle from product discovery and qualification, through ordering and orchestration, to fulfillment and operational tracking.

    Architectural principles

    Before exploring specific patterns, it is important to clarify the architectural perspective used in these prototypes.

    TM Forum APIs should be treated as:

    • stable integration contracts
    • domain boundaries between systems
    • interoperability interfaces

    They should not automatically define internal architecture, internal data models, or orchestration strategy.

    The core principles applied here:

    • Use TMF APIs as integration boundaries rather than internal models.
    • Implement TMF APIs as API facades / anti-corruption layers when integrating legacy or vendor systems.
    • Keep orchestration inside a domain-owned Order Management / Orchestrator (COM) rather than in external workflow platforms by default.
    • Combine synchronous APIs at the boundaries with asynchronous lifecycle feedback where it improves resilience and decoupling.
    • Support incremental modernization rather than big-bang transformations.

    In practice, many telecom transformations fail when TM Forum APIs are treated as architectural frameworks rather than interoperability contracts.

    End-to-End flow overview

    To understand how these TM Forum Open APIs work together in a pragmatic integration architecture, it is useful to examine the complete lifecycle from customer interaction to operational service state.

    Rather than presenting TMF APIs as isolated endpoints, this architecture shows how they form a set of integration contracts between clearly separated domains: digital engagement, commercial management, order orchestration, and service fulfillment.

    The goal is not to prescribe a rigid framework, but to illustrate how standardized APIs can be combined into a coherent flow while preserving domain autonomy and minimizing coupling between systems.

    Several important design choices shape this architecture:

    • Digital channels interact only with stable TMF contracts rather than internal system implementations.
    • Qualification is separated into commercial validation (product offering qualification) and technical feasibility (service qualification), preventing late-stage failures during fulfillment.
    • Product ordering defines the boundary between commercial intent and operational execution.
    • A domain-owned order management system performs orchestration, avoiding centralized integration bottlenecks.
    • Operational reality is reflected through service and product inventories, enabling lifecycle tracking and reconciliation.

    The diagram below presents a high-level view of this lifecycle, emphasizing architectural responsibilities rather than implementation details.

    Pragmatic Integration Patterns Using TMF620, TMF679, TMF622, TMF637, TMF641, TMF633, TMF645 and TMF638:
- TMF620 Product Catalog Management
- TMF679 Product Offering Qualification
- TMF622 Product Ordering Management
- TMF637 Product Inventory Management
- TMF641 Service Ordering Management
- TMF633 Service Catalog Management
- TMF645 Service Qualification Management
- TMF638 Service Inventory Management

    The lifecycle begins in a Digital Channel / BFF (Backend-for-Frontend). The BFF performs synchronous interactions with commerce-facing APIs:

    • TMF620 Product Catalog is used to browse and retrieve commercial offerings.
    • TMF679 Product Offering Qualification validates eligibility and configuration constraints for the selected offering. In some implementations, qualification may require resolving offer/spec details from the catalog — this is treated as an optional supporting lookup, not a mandatory dependency.
    • TMF645 Service Qualification checks serviceability (address / coverage / resource constraints). This keeps “can we technically deliver this?” separate from “is this product commercially valid?”, reducing hidden coupling and late-order failures.

    Once the customer confirms the purchase, the channel submits the request via TMF622 Product Ordering. This API acts as a key architectural boundary: it captures commercial intent using a standardized contract, while shielding downstream systems from channel-specific variations.

    Behind TMF622 sits the Customer Order Management System / Orchestrator (COM). The COM owns the order lifecycle and orchestration logic and is responsible for decomposing a product order into service-level actions. The COM then triggers fulfillment through TMF641 Service Ordering.

    Service activation executes the service order using underlying network/service platforms. During execution, the activation domain may retrieve service specifications via TMF633 Service Catalog, and it updates operational reality via TMF638 Service Inventory, which represents the authoritative record of deployed service state.

    A critical part of the lifecycle is feedback and reconciliation. Fulfillment results and service state updates flow back asynchronously to the COM to advance and complete order state:

    • activation status / fulfillment result (primary driver of order progression)
    • service state / reconciliation (authoritative deployed state used for alignment and correction)

    The COM then updates TMF637 Product Inventory, keeping responsibilities separated:
    service inventory reflects deployed technical reality, while product inventory reflects customer-facing product/subscription state.

    Note: Shopping Cart (TMF663) is omitted for simplicity in this diagram. It can be implemented inside the BFF (internal cart) or exposed as a separate TMF API depending on the channel strategy.

    What’s next

    The purpose of this publication is to establish the architecture and integration patterns without drowning in specification-level detail. In the next publications, I will describe the detailed flows and state transitions per step — including practical examples of request/response sequences, event-driven feedback, and data model mappings (qualification inputs, order decomposition outputs, inventory updates, and reconciliation logic).