- How EX183 Is Organized and What the Seven Domains Represent
- Exam Format: Hands-On Work on JBoss EAP 7
- Domain 1: Bean Validation
- Domain 2: JPA Mapping
- Domain 3: JPA Query
- Domain 4: Messaging
- Domain 5: REST Services with JAX-RS
- Domain 6: Security
- Domain 7: CDI
- The Stateless EJB Thread Running Through Everything
- Sequencing Your Preparation Across the Domains
- Fees, Delivery, Retakes and Renewal
- Frequently Asked Questions
- EX183 lists seven preparation domains: bean validation, JPA mapping, JPA query, messaging, JAX-RS REST services, security and CDI.
- Red Hat publishes these domains unweighted, so no percentage split exists; prepare all seven rather than gambling on a favorite.
- The exam is hands-on against JBoss EAP 7, and configurations must persist after a reboot.
- Stateless EJB business logic is supported by the exam overview, so practice it alongside the seven headings.
How EX183 Is Organized and What the Seven Domains Represent
The credential many candidates still search for as RHCEAD is formally the Red Hat Certified Specialist in Enterprise Application Development, delivered through exam code EX183. The older "Developer" wording survives in the credential URL and some browser titles, which is why the RHCEAD label persists in search. If you want the naming history, our explainers on what RHCEAD stands for and what RHCEAD certification is cover it. This article stays focused on content: what each of the seven areas asks you to do.
Red Hat's EX183 objectives page, which we last verified against the live listing in October 2026, groups the study points under seven headings. Two caveats matter for planning:
- The headings are unweighted. Red Hat does not publish a percentage-based blueprint for EX183. Any site quoting "Domain 3 is 18% of the exam" is inventing a number.
- The seven headings are not presented as an exhaustive official count. Stateless EJB business logic appears in the exam overview and the credential competency list, so it belongs in your preparation even though it is not an eighth heading.
For a broader preparation plan, see the RHCEAD study guide. This page is the domain-by-domain companion to it.
Exam Format: Hands-On Work on JBoss EAP 7
EX183 is a performance-based enterprise Java development assessment, not a multiple-choice question bank. You work against JBoss Enterprise Application Platform 7, building and configuring application components and server resources to meet stated requirements. That shapes how you should read the domains: each one is a skill you demonstrate, not a definition you recall.
- Persistence of configuration: Changes must survive a reboot. A datasource, security domain or messaging resource that works only in a running session is not a finished task.
- Documentation rules: Internet access and candidate-supplied documentation are prohibited. The documentation shipped with JBoss EAP is supplied, so knowing your way around it is a practical skill.
- Duration: The reviewed exam page does not specify a duration. Confirm the timer on your booking rather than relying on forum claims.
- Recommended background: Solid Java SE knowledge, familiarity with JBoss Developer Studio on RHEL, and AD183 preparation. There are no formal prerequisites; see RHCEAD requirements for the eligibility picture.
Because pass marks and task counts are not published in the sources we rely on, we do not quote them. Our pages on the RHCEAD passing score and RHCEAD pass rate explain what is and is not publicly known.
Domain 1: Bean Validation
Bean validation
Expect to constrain application data declaratively and see those constraints enforced where the application accepts input.
- Applying built-in constraint annotations to fields and properties of model classes
- Writing a custom constraint annotation with its validator class
- Using validation groups to apply different rules in different contexts
- Triggering validation and handling constraint violations, including in REST and persistence flows
Bean validation is often the shortest domain to learn and the easiest place to lose time through small mistakes. A constraint that is declared but never triggered, or a custom validator that is not registered correctly, fails silently in the way that costs minutes during a timed lab. Practice until you can add a custom constraint, wire its validator and prove it rejects bad input without consulting documentation.
Validation also interacts with other domains. A JPA entity carrying constraints will validate on persist by default in a Java EE container, and a JAX-RS resource can reject invalid payloads. Rehearse those crossovers, not just isolated annotations.
Domain 2: JPA Mapping
JPA mapping
This domain is about turning an object model into a relational schema using the Java Persistence API, running on the EAP-managed persistence layer.
- Entity declaration, primary keys and generation strategies
- Relationships: one-to-one, one-to-many, many-to-one and many-to-many, including owning side versus inverse side
- Fetch types and cascade behavior, and what each does at runtime
- Embeddable types, inheritance mapping strategies and enumerated or temporal fields
- The persistence unit definition and the datasource it binds to
The persistence unit and datasource are where the exam's server-side nature shows. A mapping that compiles is not enough; the datasource must exist in the server configuration, persist across a restart, and match what the persistence unit references. Candidates who only ever developed against an embedded setup are often surprised here.
Domain 3: JPA Query
JPA query
Once the data model is mapped, you must retrieve and manipulate it with the query facilities JPA provides.
- JPQL: selects, joins, parameters, aggregates, grouping and ordering
- Named queries declared on entities versus queries built in code
- The Criteria API as a type-safe alternative
- Native queries and when they are appropriate
- Result handling: single results, lists, and projections beyond whole entities
Practice writing queries against your own mapped entities from a blank file. JPQL operates on entity names and attributes, not table and column names, and mixing the two is a classic error. Also drill the difference between a join and a fetch join, because it affects both correctness of results and lazy-loading behavior you may be asked to control.
Mapping and query are tightly coupled. Plan to study them as a pair, because a query task will usually assume you can set up or fix the underlying mapping first.
Domain 4: Messaging
Messaging
Asynchronous communication on JBoss EAP 7 is handled through the Java Message Service on the platform's messaging subsystem.
- Defining queues and topics in the server configuration so they persist after reboot
- Producing messages from application components via JMS
- Consuming messages with message-driven beans, including activation configuration
- Point-to-point versus publish/subscribe semantics
- Transactions and acknowledgment as they affect message delivery
Messaging is the domain where server configuration and application code meet most visibly. You may need to create the destination, then write both the producer and the consumer, then verify a message actually flows end to end. Practice that complete loop. A message-driven bean that deploys cleanly but listens on a destination that was never configured is a very common failure pattern.
Understand the difference between queue and topic behavior well enough to explain why a given consumer received or did not receive a message. That diagnostic ability is what saves time when something does not work on the first try.
Domain 5: REST Services with JAX-RS
REST services with JAX-RS
This domain covers building RESTful endpoints that expose application logic over HTTP.
- Resource classes, application activation and path mapping
- HTTP method annotations, path and query parameters, and request bodies
- Content negotiation and producing or consuming JSON and XML
- Response construction, status codes and exception mapping
- Injecting EJBs, entity managers or CDI beans into resources
JAX-RS tasks typically sit on top of the other domains. A resource that validates input (Domain 1), reads and writes entities (Domains 2 and 3) and delegates to a stateless EJB is a realistic composite. Build a small end-to-end service in your lab and invoke it with a command-line HTTP client until the request and response details feel routine.
Pay attention to status codes and error handling. Returning the correct response for a missing resource or an invalid payload is a behavior a task can test, and it is easy to neglect while focusing on the happy path.
Domain 6: Security
Security
Securing applications on JBoss EAP 7 combines deployment-level declarations with server-side security configuration.
- Authentication mechanisms configured for a web application or REST service
- Security domains and login modules, and how the server resolves users and roles
- Role-based authorization via annotations and deployment descriptors
- Securing EJB methods and web resources by role
- Setting up users and roles on the server so access works after a restart
Security is where reboot persistence bites hardest. Adding a user or defining a security domain in a way that does not survive a restart is an easy mistake with a clear consequence. After every security change, restart the server in practice and re-verify access for both a permitted role and a forbidden one.
Key Takeaway
For each protected resource, test three cases in your lab: an authorized user, an authenticated user without the role, and an anonymous request. If you can predict and confirm all three outcomes, you understand the configuration.
Domain 7: CDI
CDI
Contexts and Dependency Injection is the glue that connects components in a Java EE application.
- Bean discovery and the role of the beans descriptor
- Injection points and qualifiers to disambiguate implementations
- Scopes such as request, session, application and dependent, and their lifecycle effects
- Producer methods and fields for objects that need custom construction
- Interceptors, decorators and events for cross-cutting concerns
CDI questions often reveal themselves as ambiguity or lifecycle bugs: two beans satisfy one injection point, or a scope causes state to live longer or shorter than intended. Learn to read the deployment error messages for unsatisfied and ambiguous dependencies, because recognizing them quickly is a real advantage under time pressure.
The Stateless EJB Thread Running Through Everything
Stateless EJB business logic is supported by the exam overview and the credential's competency list even though it is not a numbered domain. Treat it as the connective tissue of your practice projects: a JAX-RS resource calls a stateless session bean, which uses an entity manager for JPA work, is secured by role, and publishes a JMS message. Practicing that stack covers most of the seven domains in one scenario.
| Domain | Where it usually appears in a realistic task | Persistence-after-reboot concern |
|---|---|---|
| Bean validation | Model classes and REST payloads | Low; mostly code-level |
| JPA mapping | Entities, persistence unit | Datasource must exist in server config |
| JPA query | Stateless EJBs and DAOs | Low; depends on mapping being correct |
| Messaging | Producers and message-driven beans | Destinations must be defined persistently |
| JAX-RS | Endpoints over EJBs and entities | Low; deployment-level |
| Security | Web, REST and EJB access control | High; users, roles and domains must survive restart |
| CDI | Injection across all layers | Low; descriptor and scope correctness |
Keep EX183 distinct from adjacent Red Hat and Java credentials. Its syllabus is its own, and borrowing topic lists from other exams will send you studying the wrong material. The RHCEAD cheat sheet condenses the facts worth memorizing, but the exam rewards hands-on fluency far more than recall.
Sequencing Your Preparation Across the Domains
Order matters because the domains build on each other. This sequence moves from foundations to integration, and it assumes a working JBoss EAP 7 lab. Adjust the pace to your own schedule; the point is the dependency order, not the calendar.
Foundations: CDI and bean validation
- Stand up your EAP 7 lab and confirm deployments and restarts work
- Practice injection, scopes, qualifiers and a custom validation constraint
Persistence: JPA mapping and JPA query
- Configure a datasource and persistence unit that survive restart
- Map every relationship type, then write JPQL, named and Criteria queries against them
Services: stateless EJBs and JAX-RS
- Wrap persistence logic in stateless EJBs
- Expose it through JAX-RS with correct status codes and validation
Server-side concerns: messaging and security
- Define destinations, build producers and message-driven beans
- Secure the full stack by role, restart, and re-verify every access case
Finish with integrated, timed run-throughs that cut across all seven domains, using original practice scenarios you write yourself rather than recalled exam content. Our practice tests can help you check conceptual gaps between lab sessions, and the difficulty guide helps you calibrate how much lab time you personally need.
Fees, Delivery, Retakes and Renewal
Domain knowledge is half the picture; the other half is the booking and credential lifecycle. Everything below comes from Red Hat's program policy sources, reviewed in October 2026.
- Price: The program-wide standard exam list price is USD500. This is not an EX183-specific checkout quote; your regional booking-cart price controls. See RHCEAD certification cost for the broader breakdown.
- Delivery: Remote, testing-center and classroom delivery are subject to booking availability. Remote candidates need LiveUSB, a successful compatibility test and the required identity and hardware checks, so run the compatibility test well before exam day. Scheduling details are in RHCEAD exam dates.
- Results: The program guide gives a window of up to five business days. No shorter EX183-specific promise is made.
- Retake: Eligible unsuccessful first individual attempts receive one free retake under Red Hat's training policies, subject to purchase or subscription eligibility periods and scheduling restrictions. Read the policy for your specific purchase.
- Renewal: Certifications are current for three years, renewable through the original exam or qualifying same-level or higher-level credentials under the current framework. For pre-framework credentials, updated renewal and mapping rules apply to the active transcript after a new exam is passed following the May 11, 2026 framework change.
If you are weighing the investment, our analyses of whether the credential is worth it and the salary evidence treat career outcomes carefully, since no certification guarantees earnings or employment. You can also browse RHCEAD jobs to see how employers describe JBoss and enterprise Java roles.
Frequently Asked Questions
Red Hat's objectives page lists seven preparation categories: bean validation, JPA mapping, JPA query, messaging, REST services with JAX-RS, security and CDI. They are unweighted, and stateless EJB business logic is also supported by the exam overview.
No published percentage weighting exists for EX183. Treat all seven areas as equally likely to matter, and be wary of any source quoting domain percentages.
No. It is a hands-on enterprise Java development assessment on JBoss EAP 7, where you build and configure real components and your configurations must persist after a reboot.
No. Internet access and candidate-supplied documentation are prohibited. The documentation that ships with JBoss EAP is provided, so learn to navigate it efficiently beforehand.
Begin with CDI and bean validation, then move to JPA mapping and query, and finish with services, messaging and security. That order follows how the topics depend on one another in a realistic application.