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.

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.”
| Area | Access | Authoritative data | Default action on failure |
|---|---|---|---|
| Public catalog | Internet read | Published product version | Serve last published version |
| Order API | Authenticated users | Order state and approval history | Block duplicate creation |
| Private DB | Application only | Order and approval ledger | No direct public access |
| Integration worker | Service account | Delivery events and retry state | Move 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.
| Path | Conditions to verify first | Evidence of passing |
|---|---|---|
| NCP | Domestic operations, account, and network requirements | Test private DB, deployment permissions, and log path |
| AWS | Existing-account integration, regions, managed capability | Reproduce identical permission, recovery, and deployment procedures |
| Oracle Cloud | Existing Oracle integration, contract, compute conditions | Confirm 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.
| Step | Processing | Failure or retry |
|---|---|---|
| 1 | Confirm authentication, entity, and approval authority | 403; no ledger change |
| 2 | Check per-entity idempotency key and body hash in the transaction | Same request returns existing result; different body returns 409 |
| 3 | Record order, approval state, and outbox in one transaction | Unique constraint blocks concurrent duplicates; failure rolls back all |
| 4 | Worker reads committed outbox | Record lock and delivery state |
| 5 | Call inventory and shipping systems | Exponential retries, then quarantine queue |
| 6 | Reflect result in order state | Operator 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.
- Public web
Serves a cacheable catalog.
- Authentication API
Confirms legal entity and role.
- DB transaction
Commits order, approval state, and outbox together.
- Outbox worker
Reads only committed events and retries external calls.
- External inventory and shipping
Returns results with the idempotency key.
- 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.
| Item | Target input | Verification record |
|---|---|---|
| RPO | 15 minutes | Difference between pre-incident acknowledged and recovered commits |
| RTO | 4 hours | From service-loss start to validated resumption, including detection and response |
| Consistency | Order, approval, and outbox match | Sample and aggregate reconciliation |
| Access | Keep environment isolated | Network 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.
| Stage | Permitted change | Action when a problem occurs |
|---|---|---|
| Expand | New columns, indexes, and read-compatible code | Roll back code if the new path has not been used |
| Backfill | Batch fill and verification | Leave progress state and stop safely |
| Switch | Enable new write and read paths | Return to earlier code only with old-schema compatibility and synchronization |
| Contract | Remove old structure after stability period | Pause, 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.