The skill that separates an EPM administrator who can maintain an application from a developer who can extend it. Fourteen modules on Groovy business rules for Planning (EPBCS) — the language, the Java API, grids, run-time prompts, metadata, focused calculations, and REST integration. Free, and built to be worked in your own application.
You need access to a non-production Oracle EPM Cloud Planning (EPBCS) environment with rights to author and deploy rules in Calculation Manager, and EPM Automate installed with a working service account. Every exercise from Module 4 onward is deployed and run for real, in your own application — you cannot learn what a rule does to a cube by reading about it, and we would rather say so before you enrol than after.
Check your subscription tier too. Groovy comes with EPM Enterprise Cloud Service, Enterprise PBCS or PBCS Plus One — a plain PBCS subscription does not include it. Thirty-second check: open Calculation Manager, start a new rule, and confirm "Groovy" is offered as a rule type.
If production is the only environment you have, please don't work through this course against it. Get a test environment first — every safety rule we teach depends on having somewhere that isn't production to be wrong in.
What you don't need: an AI account. Despite our name, this is a straight technical course — no Claude account, no AI tooling, nothing to sign up for. Everything you need is your EPM environment, a text editor, and Oracle's API reference. If your organisation restricts AI tools, that is no barrier to completing this course or earning the certificate.
Built for people who already work in EPM and have hit the wall where the application can't do what the business is asking for. You do not need Java or Groovy experience. You do need to know what a cube, a dimension, a form, and a business rule are.
Taught on Planning (EPBCS) — but the skill is broader. Groovy is a Cloud EPM platform capability: Oracle supports it in Planning and FreeForm, in Enterprise Profitability and Cost Management, in Tax Reporting, and in Financial Consolidation and Close (for On-Demand rules). We teach it on Planning because Planning exercises the API most fully — form grids, edited cells, run-time prompts, Smart Push — which makes it the best vehicle for learning the model. If you work in FCCS, TRCS or EPCM this course is still for you; you'll need a Planning or FreeForm environment to do the exercises in, and the closing module sets out exactly what carries across to your business process and what doesn't.
Why it's free: Groovy is the highest-pain, lowest-supply skill in the Australian EPM market, and the only existing options are Oracle's reference documentation and consultancy tribal knowledge. We'd rather be the people who taught you. Registration is required so your progress, capstone and certificate have somewhere to live — there's no card, no trial, and no upsell inside the course.
Write, deploy and debug Groovy business rules — the language fundamentals, the development loop, and the rule types
Navigate the Groovy Rules Java API object model — EpmScript, Operation, Application, Cube, DataGrid
Work with grids and run-time prompts — iterate edited cells, alter values, colour cells, and enforce real business validation at save
Generate Essbase calc scripts dynamically, so a rule calculates only what the planner actually changed
Look things up and troubleshoot in the Java API reference — the skill that keeps working as Oracle ships updates
Connect to external resources and REST APIs from a rule, safely — including moving data slices between environments
Leave with a Rule-Ready Pack — working rules, a measured performance retrofit, an integration script and a prompt library, all built in your own application
Modules 1–3 are pure language work and run locally. From Module 4 on, everything is deployed and run in your non-production environment.
BigDecimal and missing isn't zeroEpmScript, Operation, Application, and the context a calc script can never haveCube, DataGrid, and how to look things up — the method that keeps you productive as the API movesEvery exercise runs on your own application. These are the shapes you'll be building.
// What changed?
def edited = operation.grid.dataCellIterator().findAll { it.edited }
if (!edited) { println 'Nothing edited.'; return }
// Derive the smallest scope that covers it
def entities = edited.collect { it.getMemberName('Entity') }.unique()
def periods = edited.collect { it.getMemberName('Period') }.unique()
// Generate, PRINT, then execute
println script
cube.executeCalcScript(script)
"Growth of 47.3% exceeds the 30% policy limit for Marketing. Adjust the value or attach a justification comment before saving."
// The API reference tells you what should be there.
// This tells you what IS there, in your release.
Cube cube = operation.application.getCube('MerPlan')
cube.class.methods
.findAll { !it.name.startsWith('get') }
.collect { it.name }.unique().sort()
.each { println " $it" }
A Groovy rule can write data, change metadata, run jobs and call other environments. The safety module comes before any code in the course, and every module ends with a check against it.
Not once, not "just to test the syntax". It's a prerequisite of the course that you have somewhere else to work — this is the one rule with no exception.
Never in script text — not in a comment, not "temporarily". A rule with a URL and password in it leaks them into every export, migration, backup and support ticket for the life of the application.
Taught as a command you've already run, not a good intention. The snapshot must exist before the run — which is why EPM Automate is a prerequisite.
Every generated calc script gets logged before it runs. This single habit catches almost every scoping mistake — including the ones in code you borrowed from a forum and skimmed.
Method signatures, menu paths and EPM Automate syntax move. We say so in the course, date-stamp the material, hedge version-sensitive detail, and teach the API lookup as a habit — your service's own API reference outranks us.
Compiling proves the syntax, not the numbers. Every exercise ends by reconciling what the rule produced against what it should have produced — and the capstone is assessed on it.
The certificate is earned on an assessed capstone, not on attendance or a completion tick.
Fourteen modules, worked in your own non-production application. No card, no trial, no upsell inside the course.
Free, self-paced, and assessed. All you need is an account and a non-production environment to be wrong in.