AEM Forms Training

The World's Leading AEM Forms Training Source

AEM Adaptive Forms (Core Components) Training

Enterprise Adaptive Forms Training

AEM Adaptive Forms built with Core Components represent the modern, lightweight evolution of form development in Adobe Experience Manager. Unlike Foundation Components, Core Components are designed with a simplified, standards-based architecture that emphasizes JSON schema-driven data binding, cleaner front-end rendering, and a stronger separation between data, logic, and presentation. Adobe explicitly recommends using Core Components for new AEM implementations, noting that Foundation Components are deprecated in AEM 6.5 and should be replaced with this more modern, extensible approach. This results in faster performance, improved maintainability, and greater flexibility for developers building scalable, enterprise-grade form solutions.

Adobe's recommendation of Core Components over Foundation Components.

This training section focuses on designing and implementing next-generation Adaptive Forms using Core Components, with a strong emphasis on real-world integration patterns and modern development practices. In alignment with Adobe’s guidance to adopt Core Components as the standard, students learn how to define and structure JSON schemas, implement efficient data binding, extend functionality with client-side technologies, and integrate form submissions with AEM workflows and XDP-based Document of Record generation. The overall goal is to equip developers with the skills needed to build high-performance, future-ready forms that align with Adobe’s recommended architecture and evolving AEM platform standards.

This training section includes the following courses:

Course Outline

Maven and Core Components (AEM Forms)

This course introduces the modern development foundation required for building AEM Adaptive Forms with Core Components, focusing on Maven-based project architecture and Adobe’s AEM Project Archetype. Students learn why Adobe mandates Maven for Core Component development and how it provides a standardized, scalable structure for managing AEM applications. The course covers how Maven handles dependency management, compiles code into deployable packages and OSGi bundles, and ensures alignment with Adobe best practices—including support for Core Components, editable templates, and modern front-end tooling.

Students then gain hands-on experience creating and working with a full AEM Forms Maven project in Visual Studio Code. The course explores the multi-module project structure (such as ui.apps, ui.content, and ui.frontend), demonstrating how teams can collaborate efficiently across front-end and back-end development. Participants also learn how to configure Core Component dependencies, build and deploy applications, and manage code using modern development tools such as Git and IntelliSense-enabled editors. By the end of the course, students will have a fully functional development environment and a solid foundation for building Adaptive Forms using Core Components.

Screenshot showing Adobe AEM Core Components in Author mode.

Introduction

This course provides a foundational introduction to AEM Adaptive Forms built with Core Components, focusing on the architecture, terminology, and design patterns that differentiate them from traditional Foundation Components. Students learn how Core Components are structured using proxy components, HTL (HTML Template Language), and JavaScript helper files, enabling a cleaner separation of presentation and logic. The course also clarifies the relationship between AEM Forms (FD) components and AEM Sites (WCM) components, helping developers understand how Adobe’s modern component framework is applied across the platform.

Students then gain hands-on experience creating Adaptive Forms using Core Components, including working with templates, components, and rule-based functionality. The course emphasizes modern development practices such as client library-based JavaScript, the use of qualified field names, and the importance of not mixing Core and Foundation technologies within the same implementation. By the end of the course, participants will have a clear understanding of Core Component architecture and will be prepared to build scalable, maintainable forms aligned with Adobe’s recommended development approach.

Templates

This course teaches how to design and manage templates for AEM Adaptive Forms built with Core Components, establishing the structural and governance foundation for modern form development. Students learn how Core Component templates differ from Foundation templates, with a focus on Structure mode, policies, and the use of proxy-based components. The course demonstrates how templates define the layout, available components, and authoring constraints, ensuring consistency and control across all forms created from the template.

Screenshot showing Adobe AEM Core Component Templates.

Students then gain hands-on experience using the Template Editor to build reusable Core Component templates, including configuring headers, footers, and form containers, as well as defining initial content such as wizard layouts and panel structures. The course also covers how to apply and manage policies to control author behavior, and how to enable templates for use in form creation. By the end of the course, participants will be able to create scalable, governed templates that streamline development and enforce best practices in Core Component-based Adaptive Forms implementations.

Radio Buttons and Check Boxes

This course provides a deep, practical exploration of configuring Radio Buttons and Check Boxes in AEM Adaptive Forms built with Core Components. Students learn how to correctly define data values and display text for radio button groups, and how to configure checked and unchecked values for check boxes so that user selections are accurately captured, persisted, and submitted. The course emphasizes how these selections are transformed into structured data and prepared for downstream processing, including XML conversion and binding to XDP templates for Document of Record (DoR) generation.

In addition to data binding, the course covers critical behavioral and usability considerations, such as mutually exclusive selection logic for radio buttons and multi-select patterns for check boxes. Students also learn how to manage edge cases like unchecked values, including the use of preserved unchecked state settings to ensure proper data handling. The course includes hands-on exercises that reinforce both functional configuration and visual styling, enabling participants to build robust, user-friendly form components that integrate seamlessly into enterprise workflows and document generation pipelines.

Visual Rule Editor

This course teaches how to implement dynamic functionality in AEM Adaptive Forms using the Visual Rule Editor for Core Components. Unlike Foundation Components, Core Component forms do not include a Code Editor, requiring developers and form authors to adopt a fully visual, function-driven approach to building logic. Students learn how to create rules that perform calculations, enforce validation, and dynamically update form behavior using the Visual Rule interface, gaining a clear understanding of how modern Core Component forms handle business logic.

Screenshot showing Adobe AEM Core Component Visual Rule Editor.

Students then explore the extensive library of built-in functions available in the Core Components Rule Editor, including mathematical, string, and data conversion functions, as well as techniques for combining multiple expressions using logical operators. The course also demonstrates how to implement common real-world scenarios such as conditional visibility, default value assignment, and multi-condition validation. In addition, students learn how to integrate custom functions into visual rules, extending functionality while maintaining a low-code authoring experience. By the end of the course, participants will be able to build sophisticated, maintainable form logic using the modern Core Components rule framework.

Client Libraries

This course teaches how to extend and customize AEM Adaptive Forms built with Core Components using Client Libraries for CSS and JavaScript. In the Core Components model, all client-side functionality and styling are managed outside of the form through structured client libraries, making them a critical part of modern AEM development. Students learn how to create and organize client libraries to manage browser resources efficiently, and how to use custom CSS to complement and override theme styling with precise, targeted selectors.

Students also gain hands-on experience developing and integrating custom JavaScript within client libraries, including the use of reusable functions and third-party libraries to enhance form interactivity. The course demonstrates how to properly reference client library categories within Core Component forms and how to structure code for maintainability and performance. By the end of the course, participants will be able to implement scalable, modular front-end solutions that align with Core Component architecture and modern web development practices.

Custom Functions

This course teaches how to extend the functionality of AEM Adaptive Forms built with Core Components by creating custom JavaScript functions that integrate directly with the Visual Rule Editor. Because Core Component forms do not include a Code Editor, developers must implement reusable logic through Client Libraries and expose that logic to form authors as selectable functions within the rule interface. Students learn how to design, build, and structure custom functions, and how to enhance usability by adding JSDoc annotations that provide clear descriptions and parameter guidance within the Visual Rule Editor.

Students also explore advanced integration techniques, including the use of the guideBridge API to interact with form fields from client-side code and the creation of reusable utilities for real-world scenarios such as data validation and dynamic drop-down population. The course emphasizes writing optimized, maintainable functions that can be centralized and reused across multiple forms and projects. By the end of the course, participants will be able to extend the Core Components rule framework with custom logic, enabling powerful low-code solutions that combine developer-built functionality with author-friendly configuration.

Extend Core Components

This course teaches the proper, Adobe-recommended approach for extending AEM Adaptive Form Core Components using proxy components. Students learn how to enhance existing components without modifying or duplicating Adobe’s source code, following best practices such as inheritance over replacement and extension over customization. The course explains how proxy components reference core components through sling:resourceSuperType and how developers can safely extend component dialogs (cq:dialog) and functionality while preserving upgrade compatibility.

Screenshot showing an Adobe AEM Core Component extended through a proxy component.

Students then gain hands-on experience building custom proxy components that extend real Core Component functionality, including adding new authoring options and implementing conditional behavior using HTL and client-side JavaScript. The course covers key architectural techniques such as wrapping and delegating rendering to the supertype, using Granite UI for dialog extensions, and structuring reusable enhancements. By the end of the course, participants will be able to create maintainable, upgrade-safe component extensions that align with modern AEM development standards and significantly expand the capabilities available to form authors.

Theme Client Libraries (Core Components)

This course teaches how to create and implement Theme Client Libraries for AEM Adaptive Forms built with Core Components, providing full control over form styling using modern front-end tooling. Unlike Foundation Components, Core Component themes are developed as standalone client libraries using technologies such as SCSS, Node.js, and build tools like npm. Students learn how to work with Adobe’s theme projects, customize styling variables, and compile themes into deployable client libraries that define the look and feel of Adaptive Forms.

Students then gain hands-on experience integrating compiled theme client libraries into a Maven-based AEM project and applying them to Core Component forms. The course covers the complete workflow—from cloning and configuring a theme project, to building and generating client libraries, to deploying and testing the theme within AEM. By the end of the course, participants will be able to create scalable, maintainable theme solutions that align with modern web development practices and deliver consistent, branded user experiences across Adaptive Forms.

These courses are part of our complete AEM Forms eLearning platform, designed for developers, administrators, and architects building modern enterprise form solutions. Visit aemforms.training to access our full library of hands-on AEM Forms courses and accelerate your expertise with real-world training.