Services

NCP, AWS, and Oracle Cloud Infrastructure Design and Operations

Cloud work is not choosing a provider name. It is making a service possible to recover and operate. Start by separating flows with different failure costs, such as ordering, payment integration, and inventory updates.

A conceptual illustration of connected computing modules arranged on a dark background.

Design scenario: a multi-entity B2B ordering and approval platform

Buyers create orders, approvers check amounts and contract terms, and operations synchronize status with inventory and shipping systems. The design separates public web, APIs, asynchronous integration work, and a private database, and assigns operational ownership. Scale and timing are design inputs and verification targets.

Organizations
18 legal entities, 4 approval roles
Peak
900 order-API requests per minute from 10:00–12:00 on weekdays as a capacity input
Data
Order and approval history stored in a private DB; no public exposure
Recovery objective
RPO target 15 minutes, RTO target 4 hours
Deployment
Two scheduled deployments a week; emergency fixes require separate approval

An ordering system is not handled with the same trust model as a public page

A public product site can be kept simple through caching and static deployment. Order creation, approval, pricing terms, and shipping status cannot. Keep this data in APIs and databases on private networks, and connect external integrations through narrow interfaces and retry rules. Operators must distinguish the state shown to a user from the actual processing state.

The design begins with responsibility boundaries, not a service list. Record who creates an order, who approves it, which system is authoritative for inventory, and where processing stops when a carrier does not respond. These boundaries prevent every incident from becoming a vague “cloud problem.”

Core boundaries
AreaAccessAuthoritative dataDefault action on failure
Public catalogInternet readPublished product versionServe last published version
Order APIAuthenticated usersOrder state and approval historyBlock duplicate creation
Private DBApplication onlyOrder and approval ledgerNo direct public access
Integration workerService accountDelivery events and retry stateMove to quarantine queue

Validate NCP first, then compare AWS and Oracle Cloud

Start with NCP: verify domestic operating requirements, contracts, existing accounts, required regions, and network connectivity. If those conditions pass, test a minimum environment in NCP. If global regions, integration with an existing AWS account, or a required managed capability is decisive, use AWS as a separate validation path. Evaluate Oracle Cloud against the same requirements when existing Oracle systems, contract terms, or required compute forms matter.

Do not decide in advance that one provider is better. Verify that required regions, instances, networking, and support are actually available in the console, and reproduce permission separation and deployment paths in a small environment. Cost is an estimate calculated with current configuration, region, commitment, storage, and network. AWS describes its Pricing Calculator as supporting estimates; it does not validate service load.

Provider validation conditions
PathConditions to verify firstEvidence of passing
NCPDomestic operations, account, and network requirementsTest private DB, deployment permissions, and log path
AWSExisting-account integration, regions, managed capabilityReproduce identical permission, recovery, and deployment procedures
Oracle CloudExisting Oracle integration, contract, compute conditionsConfirm connectivity, monitoring, and operating ownership

Order requests have idempotency and state transitions

The client includes an order key. After confirming authentication, legal entity, and approval authority, the API records the order ledger, approval state, and outbox event together in one DB transaction. If it cannot record any one of them, it commits none. A repeat request with the same key returns the existing result rather than creating a new order. Only after commit does a worker deliver to external inventory and shipping systems.

Order processing sequence
StepProcessingFailure or retry
1Confirm authentication, entity, and approval authority403; no ledger change
2Check per-entity idempotency key and body hash in the transactionSame request returns existing result; different body returns 409
3Record order, approval state, and outbox in one transactionUnique constraint blocks concurrent duplicates; failure rolls back all
4Worker reads committed outboxRecord lock and delivery state
5Call inventory and shipping systemsExponential retries, then quarantine queue
6Reflect result in order stateOperator can see basis for reprocessing

Only external delivery is asynchronous. Ledger, approval state, and delivery intent must share a commit so retries can prevent duplicate orders and trace omissions.

External systems must also reject duplicates by event ID or expose their processing result. If only the response is lost after successful delivery, reconcile the external reference number; if the result cannot be confirmed, inspect it in the quarantine queue. A retry can increase delivery attempts, so it must not blindly rerun external purchasing or fulfillment.

Operational path for ordering, approval, and integration work
  1. Public web

    Serves a cacheable catalog.

  2. Authentication API

    Confirms legal entity and role.

  3. DB transaction

    Commits order, approval state, and outbox together.

  4. Outbox worker

    Reads only committed events and retries external calls.

  5. External inventory and shipping

    Returns results with the idempotency key.

  6. Ledger and audit

    Updates delivery results and recovery-review records.

Backup is a recovery procedure, not a setting

Do not expose the private DB directly to the internet. Permit only the application and restricted operational paths, and separate credentials from deployment configuration. Set backup frequency, retention, and encryption after confirming data classification and entity requirements. RPO of 15 minutes and RTO of 4 hours are objectives in this scenario. Measure actual values through recovery exercises and incident records.

RPO is the difference between the last acknowledged commit immediately before an incident and the last recovered commit. RTO runs from the start of service loss until the restored environment completes order, approval, and external-delivery validation and resumes service. In an isolated environment, a recovery exercise reconciles ledger counts and state transitions and confirms connection strings do not point to production.

Recovery verification record
ItemTarget inputVerification record
RPO15 minutesDifference between pre-incident acknowledged and recovered commits
RTO4 hoursFrom service-loss start to validated resumption, including detection and response
ConsistencyOrder, approval, and outbox matchSample and aggregate reconciliation
AccessKeep environment isolatedNetwork and secret-value check results

Expand a schema, switch it, then remove it last

Replacing code and the database together during an order-state column change makes rollback difficult. In the expand stage, add new columns or tables so both old and new code can read them. Switch the write path in a later deployment and confirm data is filled. Switch the read path, then remove the old structure only after a stability period.

Do not run migrations automatically at application startup. Run an approved job and record the target version, expected locks, and reversibility. Returning to previous code is allowed only when the earlier schema can read new data and backfill has caught up. Otherwise pause writes or deployment, reconcile consistency, and repair forward.

Expand–contract deployment rules
StagePermitted changeAction when a problem occurs
ExpandNew columns, indexes, and read-compatible codeRoll back code if the new path has not been used
BackfillBatch fill and verificationLeave progress state and stop safely
SwitchEnable new write and read pathsReturn to earlier code only with old-schema compatibility and synchronization
ContractRemove old structure after stability periodPause, reconcile, and repair forward

Alerts must reach the service owner

Split operating responsibility among the platform team, product team, and external-integration owner. The platform team owns networking, deployment permissions, and backup recovery exercises. The product team owns order state transitions and user-impact judgment. The integration owner manages partner response failures and reprocessing criteria. This is better than sending every alert to everyone: define which event requires whose first action.

  • Order API error rate and latency: product on-call checks
  • Growing quarantine queue: integration owner classifies cause
  • DB backup or recovery-verification failure: platform owner stops changes
  • Permission-policy change: deploy after recording security approval

The operations dashboard includes pending order count, retry count, oldest unprocessed event, deployed version, and recovery-exercise date alongside request count.

Migration moves traffic and responsibility together

First confirm one entity’s read-only catalog and private DB connection. Next create order drafts without external delivery. Once order, approval, and outbox records are verified in one transaction, connect real orders for a small number of entities. Finally agree entity-specific cutover windows and reversal conditions before expanding. On state mismatch, stop new delivery and reconcile ledger and outbox.

Acceptance is not provider selection itself. Confirm private DB access is separated, idempotent requests do not create duplicate orders, deployment and recovery rehearsals occurred, and recovery measurements were recorded.

Materials to provide before design begins

Provide current order and approval flows, legal-entity and role lists, ownership boundaries for external inventory, shipping, and payment systems, plus existing cloud accounts and network constraints. Peak periods, unacceptable duplicate processing, and data-retention rules are also needed. For costs, a summary that removes account identifiers and contractual secrets but separates region, commitment, storage, and network costs is sufficient.

First define a scope that can verify permissions, deployment, recovery, and handoff for one entity and one order flow. The result becomes evidence for retaining NCP, evaluating AWS or Oracle Cloud, or choosing a hybrid structure.

A cutover plan records not only the data-move date but the moment responsibility moves: who receives alerts in the new environment, when deployment authority is removed from the old one, and which ledger to inspect during a partner incident. Keep the read-only period, change freeze, and post-cutover observation period in the same document. Without this, both environments can become sources of truth.

Cost review exposes usage assumptions rather than a monthly total: peak and ordinary requests, retention, backup storage, network transfer, and operator time. Re-run deployment and recovery procedures proven with one provider against the same acceptance criteria on another. Price differences are input to selection, not a substitute for data boundaries and operating procedures.

Incident exercises do not assume only provider outages. Check more common failures in order: mistaken permission deployments, expired secrets, slow external inventory APIs, worker interruption, and migration locks. Each exercise records detection time, first owner, temporary mitigation, cause record, and follow-up change. This is operating material to reduce repeat mistakes, not a way to generate more alerts.

References