Deep dives on Oracle Integration Cloud, VBCS architecture, PL/SQL patterns, and lessons from enterprise deployments.
100 posts
Embed Oracle Analytics Cloud reports and dashboards directly inside VBCS applications — so users get analytics in context without switching tools.
Some Oracle Cloud modules expose ADF Business Components service interfaces rather than REST APIs. Here's how to connect VBCS applications to ADF BC endpoints.
VBCS's built-in validators cover the basics, but enterprise forms require context-aware, cross-field, and server-side validation. Here's how to implement all three.
How to structure navigation for large VBCS applications — flows, routers, side navigation, tabs, and drill-down patterns that scale well as the app grows.
VBCS applications can be deployed as Progressive Web Apps with offline capabilities — here's how to structure apps for mobile field workers and low-connectivity environments.
Choosing the wrong variable scope in VBCS leads to subtle bugs and performance issues. Here's a clear guide to application, flow, page, and component-level variables.
Enterprise VBCS applications almost always need bulk data import and export. Here's the right architecture for each — from simple CSV downloads to complex Excel uploads.
How to trigger email notifications, in-app alerts, and Oracle Notifications Service messages from VBCS applications and their backing OIC integrations.
VBCS includes the full Oracle JET data visualization library — charts, gauges, sparklines, and more. Here's how to use them effectively in enterprise applications.
How authentication works in VBCS applications — user sessions, token management, and integrating with Oracle IDCS for single sign-on.
OIC supports multiple active versions of the same integration — understanding when and how to use versioning prevents breaking changes from disrupting production.
Event-driven architectures using publish/subscribe patterns in OIC — using Oracle Streaming, ATP queues, and OIC's native event triggers for decoupled integrations.
Proven patterns for common Oracle Cloud integration challenges — canonical data model, hub-and-spoke topology, idempotent processing, and saga-based distributed transactions.
File handling in OIC goes beyond the simple FTP adapter use case — here's how to handle large files, binary content, Base64 encoding, and chunked processing correctly.
The productivity tools and utilities that experienced Oracle Cloud consultants rely on — from API testing to schema exploration to productivity shortcuts.
How OAuth 2.0 authentication and JWT tokens work in Oracle Cloud — understanding the flows that OIC, VBCS, and Fusion REST APIs rely on.
Slow OIC integrations are usually caused by a handful of predictable patterns. Here's how to diagnose and fix them systematically.
Beyond code — how to version control OIC lookups, VBCS design-time configurations, BIP templates, and environment-specific settings across dev, test, and production.
Oracle HCM Cloud exposes a comprehensive REST API — here's how to connect OIC to HCM for employee data sync, position management, and payroll interfaces.
The MERGE statement combines INSERT, UPDATE, and DELETE into a single atomic operation — the most efficient way to synchronise data between tables.
Making reports more readable through intelligent conditional formatting — traffic lights, highlighted rows, threshold-based colours, and dynamic icons.
Slow BI Publisher reports and OTBI analyses frustrate users and load database systems. Here's a systematic approach to diagnosing and fixing report performance.
A methodical guide to finding and fixing issues in OIC integrations and VBCS applications — from reading error logs to isolating failures in complex orchestrations.
Moving integrations from development to test to production in OIC is more involved than it looks — here's a reliable promotion workflow that avoids common pitfalls.
Database links let Oracle SQL access data on remote Oracle databases as if it were local — essential for EBS-to-Cloud migrations and cross-system reporting.
Oracle OBIEE is being superseded by Oracle Analytics Cloud. Here's what changes, what stays the same, and how to plan your migration.
Controlling who can see what in BIP reports — data security via SQL parameters, report-level access, and role-based catalog permissions.
Getting useful help from Oracle Support quickly is a skill. Here's how to write SRs that get resolved faster — with the right information, the right severity, and the right approach.
OIC's JavaScript action lets you execute custom logic inline — useful for complex transformations, but easy to overuse. Here's the right approach.
A methodical guide to identifying and fixing SQL and PL/SQL performance problems — from AWR reports and TKPROF to specific anti-patterns to avoid.
How to set up live connections between OAC and Fusion Cloud for real-time analytics — direct database connections, OTBI feeds, and the Fusion Analytics Warehouse approach.
How to test and validate performance before go-live for OIC integrations, VBCS applications, and BIP reports — load testing tools, benchmarks, and what to measure.
Choosing between parallel and sequential execution in OIC orchestrations can have a significant impact on performance and reliability — here's when to use each.
Oracle's REGEXP functions bring the power of regular expressions to SQL queries — for validation, extraction, and transformation of string data.
When your data isn't in a database, BI Publisher can consume XML files directly — useful for reporting on OIC integration outputs, FBDI staging results, and custom data extracts.
The Connectivity Agent bridges the gap between OIC and systems that live behind your firewall — here's how to install, configure, and maintain it reliably.
A practical toolkit for debugging PL/SQL code — from DBMS_OUTPUT and logging tables to the SQL Developer debugger and tracing.
How to apply Agile and Scrum practices to OIC/VBCS projects — sprint structure, user stories for integrations, estimation, and managing client expectations.
Oracle's CONNECT BY clause enables elegant tree traversal — org charts, bill of materials, category hierarchies, and menu structures.
The Database Adapter is one of OIC's most powerful connectors — here's how to use it safely for queries, stored procedures, and batch operations.
How to surface key performance indicators from Fusion Cloud data — using OTBI KPIs, BIP dashboards, and linking KPIs to operational detail for drill-down.
Materialized views store pre-computed query results, dramatically speeding up expensive aggregations, joins, and reports that run frequently on large datasets.
VBCS debugging is part visual designer, part browser devtools. Here's the systematic approach that finds bugs faster than random experimentation.
How to build a career in Oracle Cloud PaaS consulting — skills to develop, niches to specialise in, how to position yourself, and what the market looks like.
Sub-templates let you define common layout elements once and reuse them across multiple reports — headers, footers, common sections, and conditional blocks.
Oracle Flashback lets you query historical data, undo mistakes, and recover from accidental changes without a full database restore — here's the complete toolkit.
Good documentation saves time, prevents errors, and enables handovers. Here's a practical set of templates for OIC integrations, VBCS applications, and Oracle Cloud projects.
Performance issues in VBCS applications almost always come from a few predictable sources. Here's how to diagnose and fix the most common ones.
Oracle Fusion ships with hundreds of standard reports. Here's how to safely customise them — copy-and-modify, data model changes, and template adjustments without breaking upgrades.
Automating File-Based Data Import so bulk data loads stop being a manual, error-prone chore — using OIC pipelines and Fusion's ESS REST APIs.
Oracle 12c+ treats JSON as a first-class citizen. Here's how to store, query, update, and generate JSON directly in Oracle SQL and PL/SQL.
Oracle updates Fusion Cloud quarterly. Here's how to manage these updates without breaking your OIC integrations, VBCS apps, and BIP reports.
How to design compelling OAC dashboards that give decision-makers the right information at a glance — canvas design, KPIs, filters, and interactive drill-throughs.
The VBCS deployment pipeline is more complex than clicking Publish. Here's a reliable approach to versioning, environment promotion, and production go-live without surprises.
Generating unique primary keys in Oracle — sequences, GENERATED ALWAYS AS IDENTITY, and patterns for distributed systems.
Technical excellence isn't enough — successful Oracle Cloud implementations need structured change management. Here's the practical framework that works.
How to automate report delivery in Fusion Cloud — using Scheduled Processes (ESS), OTBI Agents, and BIP scheduling for time-based and event-driven distribution.
Lookup tables are one of OIC's most powerful and underused features. Here's how to use them for code translations, configuration management, and environment-specific settings.
Cursors are fundamental to PL/SQL row processing. Here's a complete guide to implicit cursors, explicit cursors, cursor FOR loops, and REF CURSORs.
How to implement role-based UI rendering, route-level access control, and audit-safe authorisation in VBCS — and where client-side checks are not enough.
When RTF templates aren't enough, XSLT-FO gives you complete control over PDF layout — page settings, complex headers/footers, and pixel-perfect formatting.
How Oracle Fusion Cloud organises its data — schemas, key tables, flexfields, and patterns that every OIC/VBCS developer needs to know.
A step-by-step guide to configuring OAuth 2.0 authentication for REST connections in OIC — covering client credentials flow, token refresh, and common pitfalls.
Understanding Oracle's query optimizer and using execution plans to diagnose and fix slow queries — from basic EXPLAIN PLAN to advanced optimizer hints.
When built-in VBCS components aren't enough, custom Oracle JET components let you encapsulate complex UI behaviour and reuse it across your application.
Pivot tables (crosstab analyses) in OTBI transform row-based data into a matrix format — essential for period-over-period comparisons and multi-dimensional reporting.
Building secure Oracle Cloud applications and integrations from the ground up — authentication, authorisation, data protection, and secure API design.
The built-in OIC monitoring dashboard is a starting point, not a production monitoring strategy. Here's how to build something your operations team can actually rely on.
Autonomous transactions run independently of the calling transaction — essential for error logging, audit trails, and certain synchronisation patterns.
The data model is the foundation of every BIP report — here's how to design efficient, flexible data models with parameters, joins, and complex data structures.
How to structure page layouts in VBCS applications that remain usable as complexity grows — covering responsive grids, shell patterns, and multi-panel navigation.
A guide to Oracle Cloud certifications relevant to OIC and VBCS specialists — which ones to pursue, what they cover, and how to prepare.
Partitioning large Oracle tables improves query performance and manageability. Here's when to partition, which strategy to choose, and how to implement each.
Beyond drag-and-drop field mapping — how to use XSLT functions, conditional logic, and custom transformations to handle real-world data complexity in OIC.
Bursting splits a single report run into multiple outputs delivered to different recipients — one execution generates hundreds of personalised PDFs or emails automatically.
Postman is the most effective tool for exploring and testing Oracle Fusion REST APIs before building OIC integrations or VBCS service connections.
Packages are the cornerstone of well-organised Oracle PL/SQL code. Here's how to design packages that are maintainable, testable, and follow Oracle best practices.
Subject areas are the heart of OTBI — knowing which subject area contains the data you need saves hours of searching. Here's a guide to the most important Fusion subject areas.
A practical comparison of Oracle Integration Cloud Generation 2 and Generation 3 — what's new, what migrates cleanly, and what needs redesigning.
Version control is essential for Oracle Cloud projects — even low-code. Here's how to use Git for OIC integration exports, VBCS code, SQL scripts, and deployment pipelines.
The three collection types in Oracle PL/SQL serve different purposes — here's when to use each and common patterns for manipulating collection data.
Oracle Analytics Cloud (OAC) is Oracle's modern cloud analytics platform — beyond traditional reporting into self-service analytics, ML, and enterprise dashboards.
The File Server adapter is one of OIC's most underused tools. Here's how to use it effectively for SFTP-based B2B flows, FBDI staging, and bulk data processing.
When SQL statements must be built at runtime — flexible reports, schema utilities, multi-tenant applications — dynamic SQL is the answer. Here's how to do it safely.
How to build truly dynamic VBCS forms — fields that appear based on other fields, validation that adapts to context, and layouts that respond to user role.
RTF templates are the most common BI Publisher layout format — here's how to install the Template Builder plugin, use BIP tags, and create professional-looking report layouts.
Identity Cloud Service and OCI IAM control authentication and authorisation across all Oracle Cloud services. Here's what Oracle Cloud developers need to know.
Patterns for designing scheduled OIC integrations that handle large data volumes, recover from failures, and don't re-process records they've already handled.
Robust PL/SQL programs handle errors explicitly and gracefully. Here's the complete guide to Oracle's exception mechanism — named, unnamed, and user-defined exceptions.
Patterns that keep a Visual Builder application maintainable as it grows past a handful of screens — and prevent the data model from becoming a liability.
Oracle Cloud Infrastructure underpins everything in Oracle Cloud. Here is what PaaS developers need to know — regions, tenancies, compartments, IAM, and the OCI console.
OTBI gives Fusion Cloud users self-service reporting directly on live transactional data — no SQL needed. Here's how to navigate subject areas, build analyses, and create dashboards.
How to build OIC integrations that fail gracefully — with structured fault scopes, idempotency checks, and actionable error logging.
Window functions like ROW_NUMBER, RANK, LAG, LEAD, and running totals transform what would require complex self-joins into readable, performant SQL.
A clear explanation of the Oracle Cloud stack — what SaaS, PaaS, and IaaS mean in practice, and how consultants fit into each layer.
The complete introduction to Oracle BI Publisher — how it fits in the Oracle Cloud stack, the report lifecycle, and the components every developer needs to understand.
Speed up PL/SQL data processing by orders of magnitude using BULK COLLECT to fetch arrays and FORALL to execute batch DML — the most impactful PL/SQL performance technique.
Service connections are how VBCS applications consume REST APIs from Oracle Fusion, OIC, and external systems. Here is the complete guide to configuring and using them.
Action chains are VBCS's visual programming model for UI events — here's how to structure them for common patterns like form submission, navigation, and API calls.
Every team running OIC in production encounters the error hospital. Used carelessly, resubmissions can create duplicate records and trigger downstream side effects.
No posts in this category yet.
New Oracle Cloud tutorials every week. No spam — unsubscribe any time.
✓ Thanks! You'll hear from us soon.
Got an OIC or VBCS topic you'd like covered? Let us know.
Thanks — we'll consider it for an upcoming post. We'll reach out if we need more details.
Something went wrong. Please email us directly at an.jangra14@gmail.com.