Skip to main content
Broadpin

From DevOps to GenDev: Automating Oracle E-Business Suite and APEX Delivery with AI

This blog was written by Johannes Michler (CTO).

Extending Oracle E-Business Suite with Oracle APEX is a proven approach. Getting those changes from development to production reliably, and building them faster, is where many teams still struggle. In this session, Broadpin CTO Johannes Michler shows how a lightweight GitOps foundation makes generative development possible, and what happened when Broadpin used AI to rebuild a customer's Oracle Application Framework (OAF) application in APEX.

Why manual releases don't scale in E-Business Suite

Automating changes in an E-Business Suite environment is harder than in most applications, because a single change often touches many technologies:

  • Code in the database: packages, procedures, functions, tables, views, triggers, and APEX applications

  • Middle tier: Java concurrent programs, OAF pages and classes, Forms and Reports

  • Metadata: BI Publisher templates, concurrent program definitions, lookups, value sets, and workflows

  • Data: many environments hold 5 to 10 terabytes that are not versioned, are refreshed by production-to-test copies, and mix seeded with custom rows

Developers rarely get their own instance and instead share a small number of development and test environments. Rolling out changes by hand in this setup causes three problems:

  • High effort: handwritten install scripts for every release, with several teams changing the same instance.

  • Error-prone releases: a forgotten object or the wrong install order means something works in development but fails in test. Rollback is manual and risky.

  • Audit pressure: ERP systems are heavily audited, so every change needs to show who made it, when, why, and who approved it.

Full-blown tools such as Oracle Enterprise Manager Application Management Pack can solve this, but they often exceed the budget.

A lightweight foundation with no additional license fees

For several customers running EBS 12.2, Broadpin has built a lightweight alternative based on standard tools. It has been in production for years at multiple long-standing EBS customers.

  • GitLab: Git repositories, issues, merge requests and reviews, and CI/CD pipelines as code

  • SQLcl: export and import of database objects and APEX applications, plus an MCP server and skills for AI agents

  • Liquibase: built into SQLcl, manages the custom schema as changesets

  • APEXlang: APEX applications as readable files

  • Plain shell scripts around FNDLOAD, XDOLoader, WFLOAD, and the Forms compiler

Broadpin deliberately does not use SQLcl Projects. They do not yet cover all EBS artifacts, and they are hard to use with many parallel feature branches whose individual go-live dates are unclear.

From issue to production, every step in Git

The workflow is the same every time. A developer opens an issue and a feature branch, builds and tests on the development environment, exports the change to Git, and lists its files in a driver file. A merge request to the test branch triggers a review and an automated install on the test environment for user acceptance testing. Only accepted features move on to pre-production and production, never the whole test branch.

The branch model behind this is simple:

  • master for production, with an optional preprod branch

  • qat_<date> for integration on test, recreated after every production-to-test copy and never merged as a whole

  • feature/<issue> for each change, merged to test first and to production only once accepted

Every artifact type has a defined export and import, so the pipeline can install anything automatically:

Artifact

Export

Import

APPS objects

SQLcl DDL

SQLcl script

Custom schema

Liquibase generate-schema

Liquibase update

APEX apps

apex export as APEXlang

apex import

BI Publisher

XDO_LOBS export

XDOLoader upload

FND objects

FNDLOAD download

FNDLOAD upload

Workflows

WFLOAD download

WFLOAD upgrade

Forms, Java

Plain files

frmcmp_batch, javac

An install script reads the driver file of the merged feature and runs the right tool for each file type. On test, the install runs automatically within seconds. Production has a manual holding point, so deployments happen at an agreed time.

Why APEXlang changes the game

APEXlang, introduced with APEX 26.1, describes APEX applications declaratively in files that both people and language models can read and write. Compared to the classic SQL export, it brings several advantages:

  • It reads like a configuration file.

  • It can be diffed and merged, so several developers can work on one application in parallel.

  • Changes are reviewable in merge requests.

  • SQLcl compiles it with precise error messages.

  • AI agents read and write it like any other code.

With SQLcl, the same commands run on a developer's laptop and in the GitLab pipeline, and a split export creates one file per page and component. Oracle also publishes official skills for SQL, PL/SQL, APEX, and APEXlang at github.com/oracle/skills, with verified grammar and examples for any coding agent. APEX 26.2 adds the ability to import a single page, which ends the problem of developers overwriting each other's work on a shared development environment.

Governance and quality gates built into the pipeline

  • Four-eyes principle: every change goes through a merge request with a review in GitLab, plus an AI code review by qodo.

  • Static analysis: dbLinter checks PL/SQL and enforces coding guidelines.

  • Unit tests: utPLSQL runs in the pipeline.

  • Dependency analysis: PITSS.CON identifies dependencies and dead code, especially for Oracle Forms.

  • Audit trail for free: issue, branch, merge request, and pipeline log document every change.

Next on the list are Playwright browser tests and SQLcl Codescan rules for APEXlang files as further gates.

From GitOps to GenDev: the project

Once all source code lives in Git, generative AI can work with it. Broadpin put this to the test with a customer whose portal on EBS had grown over many years. It combined custom OAF pages, Oracle Forms, APEX components, and more than 100,000 lines of PL/SQL, and it had become hard to maintain. The goal: rebuild it in Oracle APEX within three months, with a modern look and feel and a maintainable code base.

The requirements were clear:

  • Same business behavior: functionality ported one-to-one, with a new user interface on top

  • Reuse the EBS logic: since there is no EBS user context over a database link, writes go to staging tables that EBS background programs process

  • Two audiences: external partners and internal staff, each seeing exactly their own data

Looks simple, is highly complex

A single document entry page shows what this means in practice. It has two linked grids, cascading lists of values, a document number check via Ajax, auto-save when switching headers, validations ported from OAF Java code, Virtual Private Database (VPD) security, and a save through an existing EBS procedure. In APEXlang, that one page comes to roughly 3,500 lines.

Target architecture

The new APEX portal sits in front of EBS 12.2 and connects through a database link. On the APEX side, views with VPD policies restrict data by partner and site, and PL/SQL packages handle validation, save logic, emails, and file transport. On the EBS side, dedicated views serve the portal, thin wrapper packages call the existing business logic, and staging and interface tables are processed by scheduled background programs.

One rule applies throughout: APEX never touches EBS tables directly. Every access goes through a view or a wrapper, secured by VPD.

The method: a digital twin first

The starting point was Broadpin's AI-based digital twin of the organization. The team brought requirements, the legacy implementation, and existing project documentation together into a model of the processes and responsibilities involved. Together with the source code in Git, this formed the context for the AI.

Behind this is Broadpin's procedure model IQPM with a customer project repository powered by Horus and a code repository in Git and the PITSS Data Cube. Legacy code and requirements go in; process models, roles, and business objects come out, down to the level of individual activities. The agent updates these models with every change, so the documentation is ready at go-live.

For query and application generation, Broadpin combines this with its own AI tooling: Broadpin Easy Query for EBS database knowledge and query generation, and the Broadpin LowCode App Generator for APEX pages and data models.

The working loop

The team worked in an iterative loop:

  1. Capture the legacy: legacy code and PITSS.CON analysis go into the Horus models.

  2. Task and plan: a clear task, a plan proposed by the agent, and approval by the team

  3. Analyze and propose: the agent works through code and models and comes back with objects and questions

  4. Generate: views, packages, APEXlang, and model updates

  5. Compile: SQLcl imports the result, and errors go straight back to the agent

  6. Deploy and test: a human deploys and tests.

Compile errors, screenshots, and test results feed back into the next round.

Broadpin tested two toolchains, and both worked well:

  • Claude Code by Anthropic, a terminal agent that works on files, several repositories, and the SQLcl MCP server, asking for approval before every action. It delivered slightly better results and needed significantly fewer self-corrections.

  • Cline with LiteLLM and Gemini on OCI, with LiteLLM as a proxy in front of OCI Generative AI. Here, the data stays in the customer's OCI tenancy.

A standing rule applied to both: check first and ask before implementing. No deploy, no commit, and no push without an explicit request.

The knowledge layer

Three layers of knowledge make the agent better over time:

  • Oracle's official skills for SQL, PL/SQL, APEX, and APEXlang as the baseline

  • Broadpin's own APEXlang skill of about 700 lines, learned from compile errors, covering details such as mandatory line endings, the 4,000-byte limit for PL/SQL per property, and the Interactive Grid grammar

  • A project memory of about 40 short notes that the agent reads at the start of every session, covering the interface pattern, VPD views, and grant conventions

The principle: every mistake is made only once, because the fix goes into the skill or the memory. All of it lives as plain files in Git and works with any agent.

Beyond code generation

Some of the biggest benefits had nothing to do with writing new code. In a final review of the EBS integration, within a code base of almost one million lines, the agent built an end-to-end understanding of the flow from the portal to the EBS background programs. It found several defects in the existing implementation, not just in the new code, and derived its own test cases, so further defects were fixed before human acceptance testing started.

During user acceptance testing, testers handed failed tests to the agent as screenshots. The agent wrote targeted queries against log and interface tables, and with system access through the SQLcl MCP server and a read-only user, it ran them itself. Every hypothesis had to be proven with data.

Reality check: what was hard

  • A shared development instance: a full APEX import replaced the whole application, so edits in the Builder and in files overwrote each other. Single-page import in APEX 26.2 solves this.

  • APEXlang is young: the grammar had to be learned through compile errors, including details such as mandatory line endings.

  • Session strategy: long sessions keep context but get compacted, in one case 19 times. The team settled on one session per area for the initial migration and separate sessions per feature for follow-ups.

  • Confidently wrong: some findings were refuted by colleagues and some theories disproved by logs. The lesson: measure, don't believe.

Humans stayed in the loop throughout. Developers reviewed all generated code, checked what worked, and refined the Oracle-provided APEXlang skills where needed.

By the numbers

  • About 100,000 lines of code across the portal repositories, covering APEXlang, database objects, and the EBS side

  • 60 person-days in total, including testing, data migration, and meetings

  • Around 1,700 lines of code per developer day

  • More than 90% of the application's source code generated from the OAF original

  • Complete process documentation in the digital twin as a by-product

What we learned

  1. DevOps comes first. A GitOps process with all source code in one place is the foundation for any AI-driven development. The legacy code in Git became the specification.

  2. APEXlang is the enabler. A declarative, file-based format makes large-scale generation practical and AI output reviewable like any other code.

  3. Context drives quality. A digital twin of the processes gives the AI the business understanding that source code alone cannot provide.

  4. Knowledge compounds. Every page got faster, because every lesson went into the skill or the memory.

  5. Troubleshooting is worth as much as code generation.

The rules of engagement that made it work: a human deploys, commits, and pushes; every task starts with a clear goal and an approved plan; the agent checks against the legacy application first and then asks; and every claim needs proof by query or log.

What comes next

The latest Oracle APEXlang skills have already made several of Broadpin's own workarounds obsolete.

Next, Broadpin wants to close the loop: the agent compiles automatically before every deploy, Playwright tests and SQLcl Codescan provide further feedback, and a GitLab MCP server lets the agent fix and rerun failed pipelines on its own.

Modernize your EBS extensions with Broadpin

Whether you want to automate your EBS deployments or move OAF and Forms applications to APEX, Broadpin brings both the tooling and the hands-on experience. Talk to our E-Business Suite and APEX experts about your modernization roadmap.

Watch the full session on the Broadpin YouTube channel.

Get in touch