OIC · Fusion · Intermediate
Oracle Integration Cloud: Building Integrations That Survive Production
Nineteen modules, nineteen labs, and an integration delivered end to end
Building an integration is the easy part. Making one that still works after a credential rotates, a payload changes shape, the network drops mid-call and somebody reruns it twice — that is the job, and it is what this course is about. For the consultant or developer who has outgrown point-to-point calls and now has to connect Fusion to systems that were not designed to talk to it. It assumes you know what a REST call is; it does not assume you have seen OIC.
EGP 3,000
175 lessons · 369 min
What you will be able to do
- Decide whether a requirement needs OIC at all, and say so before the licence is bought.
- Build and secure connections to Fusion, to a database, and to a partner over FTP.
- Map between two schemas that disagree, and prove the mapping with data that is not the happy path.
- Design an integration that is safe to retry, so a duplicate payment is impossible rather than unlikely.
- Handle faults so a failure is visible, recoverable and attributable within minutes.
- Promote an integration between environments without carrying test endpoints into production.
- Monitor a live estate and answer "did it run, and did it work" without opening the design.
- Read an OIC quarterly update for the two things that actually break integrations.
What you should know first
- You know what a REST call is and can read JSON and XML without looking things up.
- You have seen at least one Fusion implementation, or have taken the Fusion Technical course.
- An OIC instance you can build in. A trial works for everything except the environment-promotion module, which needs two.
- No prior OIC, SOA or middleware experience is assumed.
What you will cover
1. Module 0 · Orientation
What this course covers, what the Fusion Technical course already covered, and how to get an instance you can build in.
- 1How this course works2 min
- 2Getting an OIC instance2 min
- 3What you should already know2 min
- 4The vocabulary, once2 min
2. Module 1 · What OIC is, and when you need it
The decision module, and the honest half of it. Most requirements do not need an integration platform, and recommending one that is not needed is a real failure.
- 1What the product actually is2 min
- 2The four patterns Fusion already handles2 min
- 3When you genuinely need OICFree preview2 min
- 4What it costs, and who pays2 min
- 5OIC and the rest of the Oracle estate2 min
- 6Gen 2 versus Gen 3, and why you care2 min
- 7What breaks: the integration that should not exist2 min
- 8Lab briefing · Six requirements, one recommendation each2 min
3. Module 2 · The console and your first integration
Getting something working end to end in one sitting, so the rest of the course has something concrete to improve.
- 1The console, and the four places you will live2 min
- 2Projects, and whether to use them2 min
- 3Your first integration, start to finish2 min
- 4Activation, and what it actually does2 min
- 5Running it, and finding the instance2 min
- 6Naming, and why it matters more than it should2 min
- 7Versions and cloning2 min
- 8What breaks: the first-week mistakes2 min
- 9Lab briefing · Build, activate, run, find2 min
4. Module 3 · Connections and adapters
A connection is a credential plus an endpoint plus a contract. Getting these right is most of what makes an estate maintainable.
- 1What a connection is2 min
- 2Choosing an adapterFree preview2 min
- 3The REST adapter2 min
- 4The SOAP adapter2 min
- 5The FTP adapter2 min
- 6The database adapter2 min
- 7Testing a connection properly2 min
- 8One connection or several2 min
- 9Connectivity agents, and when you need one2 min
- 10What breaks: four connection failures2 min
- 11Lab briefing · Three connections, three systems2 min
5. Module 4 · The Fusion adapter in depth
The adapter you will use most. It hides a great deal, and knowing what it hides is the difference between a fast build and a long afternoon.
- 1What the Fusion adapter gives you2 min
- 2Browsing the catalogue2 min
- 3Business objects versus services2 min
- 4Subscribing to a business event2 min
- 5The service account and its roles2 min
- 6Bulk operations and the file route2 min
- 7Callbacks and long-running operations2 min
- 8ERP integration patterns2 min
- 9Reading a Fusion fault2 min
- 10Surviving a Fusion quarterly update2 min
- 11What breaks: five Fusion adapter failures2 min
- 12Lab briefing · Read and write Fusion from OIC2 min
6. Module 5 · Mappings and transformations
FLAGSHIP. Where two systems that disagree are reconciled. A mapping error does not fail — it posts wrong data with every appearance of success.
- 1What a mapping really isFree preview2 min
- 2The mapper, practically2 min
- 3Required, optional and the empty element2 min
- 4Repeating elements and loops2 min
- 5Conditional mapping2 min
- 6Functions: strings, numbers and dates2 min
- 7Dates and time zones, carefully2 min
- 8Numbers, precision and currency2 min
- 9Lookups inside a mapping2 min
- 10Testing a mapping with real data2 min
- 11Namespaces, and the errors they cause2 min
- 12Keeping a mapping maintainable2 min
- 13What breaks: five mapping failures2 min
- 14Lab briefing · Map two schemas that disagree2 min
7. Module 6 · Orchestration patterns
Putting several calls in an order, with branching and state. Where OIC earns its licence, and where an orchestration becomes a program nobody can maintain.
- 1App-driven versus scheduled2 min
- 2Invokes, and the shape of a flow2 min
- 3Switch, and branching honestly2 min
- 4Loops over collections2 min
- 5Local variables and assignment2 min
- 6Sub-integrations and reuse2 min
- 7Synchronous versus asynchronous2 min
- 8Stitching in a database or file step2 min
- 9When an orchestration is too big2 min
- 10What breaks: three orchestration failures2 min
- 11Lab briefing · Build a four-step flow2 min
8. Module 7 · Scheduled integrations and file handling
Most real integration is files on a schedule. Unglamorous, and where the majority of production incidents actually come from.
- 1Scheduling an integration2 min
- 2Parameters and run state2 min
- 3Reading files: patterns and directories2 min
- 4The staging problem2 min
- 5Large files and chunking2 min
- 6Writing files a partner can read2 min
- 7Archiving and idempotent file processing2 min
- 8Catching the file that never arrived2 min
- 9What breaks: four file failures2 min
- 10Lab briefing · A nightly file, done properly2 min
9. Module 8 · Error handling, faults and retries
FLAGSHIP. Every integration fails eventually. Whether that is a five-minute recovery or a week of reconciliation is decided here, at design time.
- 1The four kinds of failure2 min
- 2Faults versus errorsFree preview2 min
- 3Scope and fault handlers2 min
- 4What to do with a caught fault2 min
- 5Retry: how many, how far apart2 min
- 6The dead letter, and who reads it2 min
- 7Partial failure in a batch2 min
- 8Compensation, and its limits2 min
- 9Alerting a human2 min
- 10Resubmission: doing it safely2 min
- 11Errors that are not failures2 min
- 12What breaks: five error-handling failures2 min
- 13Lab briefing · Break it five ways2 min
10. Module 9 · Idempotency and duplicate prevention
Its own module because this is where money gets paid twice. Every integration is retried eventually, by a scheduler, a partner, or a person clicking resubmit.
- 1Why every integration is retriedFree preview2 min
- 2What idempotency means here2 min
- 3Choosing a correlation key2 min
- 4Where to enforce it2 min
- 5When the target has no natural key2 min
- 6Timeouts: the ambiguous outcome2 min
- 7Idempotency across a whole file2 min
- 8What breaks: three duplicate scenarios2 min
- 9Lab briefing · Make a payment flow safe to retry2 min
11. Module 10 · Business events and publish/subscribe
Reacting to something happening, rather than asking repeatedly whether it has. Cheaper, faster, and harder to reason about when it fails.
- 1Event-driven versus polling2 min
- 2Fusion business events, in practice2 min
- 3Subscribing without losing events2 min
- 4Ordering, and why you cannot rely on it2 min
- 5At-least-once delivery2 min
- 6OIC events between integrations2 min
- 7What breaks: three event failures2 min
- 8Lab briefing · Subscribe, drop, and catch up2 min
12. Module 11 · Lookups, libraries and reuse
Keeping the things that change out of the things that do not. Small module, and the difference between an estate you can maintain and one you rebuild.
- 1Lookups: the cross-reference table2 min
- 2Editing a lookup safely2 min
- 3JavaScript libraries in OIC2 min
- 4Reusable connections and naming2 min
- 5Configuration versus hard-coding2 min
- 6What breaks: the lookup nobody owned2 min
- 7Lab briefing · Externalise the hard-coded values2 min
13. Module 12 · Security: credentials, certificates and network
FLAGSHIP. An integration holds credentials to several systems at once, which makes it the most valuable thing in the estate to compromise.
- 1What an integration actually holds2 min
- 2Where credentials liveFree preview2 min
- 3The service account and least privilege2 min
- 4OAuth, and which grant to use3 min
- 5Certificates: trust, identity and expiry2 min
- 6Rotation without an outage3 min
- 7Network: allowlists and private endpoints3 min
- 8What ends up in a log3 min
- 9What breaks: four security failures3 min
- 10Lab briefing · Audit an integration for exposure2 min
14. Module 13 · Monitoring, tracking and alerting
Answering "did it run, and did it work" without opening the design. The module that decides whether you find out about a failure before the client does.
- 1The monitoring console2 min
- 2Tracking variables: the one design decisionFree preview2 min
- 3Reading a failed instance2 min
- 4Payload retention, and its limits2 min
- 5Errors versus rejections in the console2 min
- 6Alerting: who, when, how loud3 min
- 7The silent failure: nothing ran3 min
- 8Reporting to the business2 min
- 9What breaks: the integration nobody knew had stopped2 min
- 10Lab briefing · Make a failure visible in five minutes2 min
15. Module 14 · Performance and throughput
What happens when the volume is ten times the demo. Mostly a design question, and almost never solved by tuning afterwards.
- 1Where the time actually goes2 min
- 2Per-record calls versus batch3 min
- 3Parallel processing, and its cost2 min
- 4Payload size and memory3 min
- 5Message packs and cost per run2 min
- 6Throttling and back pressure3 min
- 7What breaks: the integration that worked in test2 min
- 8Lab briefing · Ten times the volume3 min
16. Module 15 · Testing an integration properly
Integrations are hard to test because half the system belongs to somebody else. What to do about that, rather than testing the happy path and hoping.
- 1What "tested" means for an integration2 min
- 2Testing without the other systemFree preview3 min
- 3Choosing test data that would fail2 min
- 4Testing the failure paths3 min
- 5Testing idempotency explicitly2 min
- 6End-to-end with the business2 min
- 7What breaks: the UAT that proved nothing2 min
- 8Lab briefing · A test plan somebody would sign3 min
17. Module 16 · Environments and promotion
FLAGSHIP. Moving an integration from test to production. The module where a mistake sends live data to a test endpoint, or the reverse.
- 1What an environment means here2 min
- 2Export and import, mechanically2 min
- 3The promotion checklistFree preview2 min
- 4Connections do not travel2 min
- 5Lookups and environment-specific values2 min
- 6Schedules after promotion2 min
- 7Versioning and rollback2 min
- 8Automating promotion2 min
- 9What breaks: four promotion failures2 min
- 10Lab briefing · Promote, and prove it is isolated2 min
18. Module 17 · Quarterly updates and OIC
OIC updates, and so does everything it talks to. Two calendars, and the integrations sit between them.
- 1Two update calendars, not one2 min
- 2Reading an OIC release note for risk2 min
- 3Adapter versions and regeneration2 min
- 4A regression pack for integrations2 min
- 5Testing in the update window3 min
- 6What breaks: after the update2 min
- 7Lab briefing · Assess a real release note3 min
19. Module 18 · Capstone: one integration, delivered
A realistic brief taken from requirement to handover, with every module in this course applied where it belongs.
- 1The brief3 min
- 2Designing before building3 min
- 3Building it2 min
- 4Proving it2 min
- 5Promoting and handing over2 min
- 6Where to go next3 min