1z0-900
Java EE 7 Application Developer
Java EE 7 Application Developer Exam Guide: What to Study and How to Prepare
The Java EE 7 Application Developer certification validates the ability to develop and deploy applications on Java Platform, Enterprise Edition 7, including web interfaces, business logic, persistence, messaging, and web services. It is aimed at developers working with the Java EE 7 platform and at candidates who need a structured way to confirm their platform knowledge. This guide helps you decide whether to follow Oracle’s learning path, build a focused lab plan, or schedule the 1Z0-900 exam only after testing your practical coverage.
What does the certification validate?
This credential is designed to confirm application development and deployment capability across Java EE 7 rather than familiarity with one isolated API. Oracle describes the certified developer as someone who can create web-based user interfaces, handle business logic, and use Java EE 7 technology in application development.
Oracle’s credential description specifically mentions JavaScript, JSPs, JSFs, and servlets for web-based user interfaces. It also identifies business-logic capability as part of the demonstrated expertise. That combination matters when planning study: a candidate who knows EJBs but cannot trace a browser request through a servlet or JSF application has an incomplete preparation profile.
The certification catalog places Java EE 7 Application Developer in the Java EE and Web Services category. The associated Oracle badge lists Enterprise JavaBeans, CDI Beans, Java Message Service, Java Persistence API, JavaServer Faces, JavaServer Pages, Java Servlets, JAX-RS, JAX-WS, Web Services, and WebSockets among the related skills. Sources: https://catalog-education.oracle.com/pls/certview/sharebadge?id=6AFD3BC463C187DF91ADFE72CC34A2E377771C8D7D5F1F87626667CA73D6FC6B and https://www.oracle.com/in/a/ocom/docs/ou-certification-catalog.pdf
Who should take this exam?
The strongest fit is a developer who already works with, or is deliberately moving toward, Java EE 7 application components and needs a formal Oracle credential. The exam is also relevant to developers whose experience is concentrated in one layer but who now need to understand how web, business, persistence, messaging, and service components operate together.
Treat the exam as a platform-integration target, not as a substitute for basic Java programming. You should be comfortable reading Java code, following object interactions, and compiling or running a small application before beginning the Java EE-specific work. The supplied official material does not state a separate prerequisite, so confirm current eligibility and registration requirements on Oracle’s certification page before booking.
Candidates coming from newer Jakarta EE versions should be especially deliberate. Familiarity with a newer namespace or API does not automatically prove knowledge of Java EE 7 behavior, terminology, configuration, or component boundaries. Use the Java EE 7 documentation and specifications as the authority for the version named by this credential.
When is another preparation route more sensible?
If your goal is current enterprise Java development rather than a Java EE 7 credential, first compare Oracle’s current certification offerings with your target role. The official sources supplied here identify the Java EE 7 exam and its learning resources, but they do not establish current retirement, replacement, or availability information. Do not infer those details from the age of the documentation; check Oracle directly before committing money or study time.
What are the official exam and delivery details?
Oracle identifies the certification as Java EE 7 Application Developer and assigns it exam code 1Z0-900. Oracle’s Java Track Pre-2023 learning path lists 1Z0-900 as an online certification exam with a stated duration of 2 hours. Use those details for initial scheduling, then verify the live registration page for the current delivery process and any candidate policies.
The supplied research does not provide a price, question count, passing score, language list, test-center policy, remote-proctoring rule, or current exam-status statement. Those details should not be filled in from third-party practice sites or assumptions about other Oracle exams. Confirm each item through Oracle when you are ready to register.
Oracle’s learning path states that candidates must register for, attend, and pass the 1Z0-900 exam to receive the official credential. The same path states that passing the exam leads to an Oracle Certified Professional credential in this field. Source: https://learn.oracle.com/ols/learning-path/developing-applications-for-the-java-ee-7-platform/88360/89175
What should you verify before scheduling?
Open the official exam or certification page immediately before purchase and confirm that the exam can be scheduled, that the listed delivery option suits your location, and that the displayed requirements match your situation. Also check identification, rescheduling, cancellation, and system requirements there. The supplied sources support the exam code and online duration, but not these operational policies.
Which skills should your study plan cover?
Build your plan around the interaction of Java EE 7 technologies. Oracle’s training outline covers web components, component-model development, persistence, transactions, web services, messaging, validation, batch processing, timers, and concurrency. A useful preparation plan therefore alternates API reading with small application tasks instead of treating every technology as an unrelated vocabulary list.
The official badge and training outline provide a reliable coverage map, but the supplied research does not include an exam blueprint with domain percentages. Consequently, this guide does not assign or compare blueprint weights. If Oracle provides a current objective list or percentage breakdown on the registration page, use that document to adjust the order and time allocated to each area.
For every topic, record four things: the component’s purpose, the lifecycle or execution context, the configuration or annotations involved, and the failure or boundary conditions. This format forces you to understand how a feature behaves in an application rather than merely recognizing its name.
Web interfaces and request handling
Study Servlets, JavaServer Pages, JavaServer Faces, and the JavaScript interaction described by Oracle as one connected web layer. Be able to explain how a request enters the application, how data is passed between layers, where presentation logic belongs, and how a response is produced. Use the Java EE 7 tutorial and API references to resolve version-specific details.
A practical exercise is a small form-driven application with a servlet endpoint, a JSP or JSF view, server-side validation, and a service call. Trace one successful request and one invalid request. Write down where validation occurs, what object carries the data, and which layer decides what the user sees. This exposes confusion that passive reading often hides.
Business components and dependency management
EJB, CDI, and component-model development form the business-logic core of the study plan. Concentrate on why a component exists, how dependencies are supplied, what lifecycle is involved, and how a transaction or security boundary affects the call. Oracle’s training explicitly includes Enterprise JavaBeans, Contexts and Dependency Injection, and component-model development.
Build a service that receives a request from the web layer and delegates to a persistence component. Then replace a direct construction or lookup with dependency injection and observe how the design changes. Your notes should distinguish CDI beans from EJBs by their roles and services rather than treating both as interchangeable labels. Consult the platform specification when a lifecycle or annotation question is ambiguous.
Persistence and transaction boundaries
JPA and JTA deserve joint study because persistence behavior cannot be separated from transaction scope. Oracle’s Java EE 7 training covers Java Persistence API and Java Transaction API use. Prepare to reason about entity state, persistence context behavior, transaction boundaries, and what an application should expect when a database operation succeeds or fails.
Create a small model with a parent entity and a related child entity. Exercise create, update, query, and rollback paths while documenting which operation starts or joins a transaction. Do not rely on a memorized annotation rule without checking the surrounding component and transaction context. The Java EE 7 API documentation and platform specification are the appropriate references for exact behavior: https://docs.oracle.com/javaee/7/.
SOAP, REST, messaging, and asynchronous work
Oracle’s training outline includes SOAP and REST web services through JAX-WS and JAX-RS, while the badge identifies JAX-RS, JAX-WS, Web Services, WebSockets, and Java Message Service as related skills. Study these as communication choices: request-response HTTP, contract-oriented SOAP, REST resources, and message-based interaction solve different integration problems.
For JAX-RS, design a resource with a clear path, representation, and response behavior. For JAX-WS, identify the service contract and endpoint responsibilities. For JMS, model a producer and consumer and note what changes when processing is decoupled from the original request. Add WebSockets to your vocabulary and architecture notes, but do not assume that knowing a browser protocol replaces understanding the Java EE component that uses it.
Oracle’s training also covers Timer services and Java EE Concurrency. Add a scheduled task and an asynchronous unit of work to your lab only after you understand the synchronous path. The point is to compare execution timing, context, error handling, and transaction implications—not to collect more annotations.
Validation, batch processing, and platform services
Bean Validation and Batch API are easy to postpone because they may appear secondary to web and persistence work. That is a mistake when the official training outline names them directly. Learn where constraints are declared, when validation is triggered, and how a batch job differs from a request-scoped operation in terms of steps, data flow, and recovery concerns.
Use a deliberately invalid input model to test validation at a boundary, then create a batch process that reads, transforms, and writes records. Keep the example small enough to inspect. For each feature, explain the lifecycle in plain language and identify the application responsibility that remains outside the API. This prevents the common error of assuming the platform automatically solves business rules or operational policy.
How should you use Oracle’s official learning resources?
Use Oracle’s learning path as the spine of your preparation and the Java EE 7 documentation as the technical reference. Oracle lists the online “Developing Applications for the Java EE 7 Platform” learning path as lasting approximately 18 hours and 23 minutes. That is a stated learning-path duration, not a promise that an individual will be exam-ready after that amount of study.
The instructor-led “Developing Applications for the Java EE 7 Platform Ed 1” course is listed by Oracle as having a duration of 5 days. Treat it as a course option rather than a mandatory requirement unless the current certification page says otherwise. Candidates with substantial experience may use the course outline to identify gaps, while newer developers may need additional hands-on practice.
The documentation hub includes tutorials, installation instructions, release notes, API documentation, the Java EE 7 platform specification, and JavaServer Faces documentation. Start with the tutorial to establish flow, move to API documentation for signatures and contracts, and use the specification or release notes when a behavior needs authoritative clarification. Sources: https://learn.oracle.com/ols/learning-path/developing-applications-for-the-java-ee-7-platform-ed-1/61529, https://education.oracle.com/pls/web_prod-plq-dad/view_pdf?c_id=D98815GC10&c_lang=I&c_org_id=32, and https://docs.oracle.com/javaee/7/
How should you read documentation efficiently?
Do not read every Java EE 7 book from beginning to end before writing code. Select one feature, read its purpose and basic tutorial, implement a narrow example, and then consult the API documentation for the classes and annotations you used. Finish by writing a short explanation of lifecycle, context, and failure behavior. Repeat this loop across the coverage map.
Keep a version-control note containing the exact Java EE 7 references you used and any terminology that differs from your workplace framework. This is particularly useful if your current projects use later APIs. Separate “I have used this” from “I can explain the platform rule” so your revision list reflects evidence rather than confidence.
What is a practical study sequence?
A productive sequence moves from the request path to business logic, then to persistence and integration. Begin with a small deployable application, add one platform capability at a time, and use each addition to test a specific concept. This creates an application-sized memory structure while exposing gaps early enough to change your schedule.
Do not start with rare or isolated features simply because they are unfamiliar. Establish the common flow first: web request, managed component, transaction-aware persistence, and response. Then add REST or SOAP, JMS, validation, batch, timers, concurrency, and WebSockets as separate exercises. Finish with mixed scenarios that require choosing more than one technology.
A first preparation phase: establish the baseline
Before studying, make a topic inventory from the Oracle training outline and badge skill list. Mark each item as “can explain,” “can implement,” or “unknown.” Also record whether your experience is based on Java EE 7 or a later platform. This baseline determines whether you need a broad refresher or a version-focused correction plan.
Set up a repeatable local workflow using the Java EE 7 installation guidance and tutorial materials. The supplied sources do not prescribe a particular application server, IDE, build tool, or operating system, so choose tools that let you deploy and inspect a Java EE 7 application and document the setup you actually used.
A second phase: build connected examples
Create one small application that contains a web entry point, a managed business service, a persistence operation, and a validation boundary. Keep the domain simple; the learning objective is component interaction. Add a REST endpoint and a JMS path as separate interfaces to the same business capability, then compare synchronous and asynchronous behavior in your notes.
At the end of each exercise, remove or alter one annotation, scope, transaction boundary, or configuration element and predict the result before running the application. This is a more useful test of understanding than copying a working example. Record the observed result only as a lab observation, not as a universal rule, and verify general behavior against Oracle documentation.
A final phase: retrieve and explain
In the final study phase, stop expanding the application and start retrieving concepts without looking at notes. Given a scenario, state which component or API you would choose, why it fits, what lifecycle or context applies, and what limitation or failure path you would check. This method tests decisions rather than recognition.
Use your error log as the revision syllabus. If you repeatedly confuse CDI with EJB, transaction scope with persistence context, or JAX-RS with JAX-WS, create a side-by-side comparison and a tiny demonstration for that distinction. Schedule the exam only when you can explain the distinction and reproduce the relevant behavior in a clean example.
How can you turn the outline into a weekly roadmap?
A roadmap should end with evidence, not with a number of videos watched. Use the official learning path for structured coverage, the Java EE 7 documentation for verification, and your own small applications for practical proof. The timing below is a flexible order of work, not an Oracle-prescribed schedule or a guarantee of readiness.
Week one should establish the web and component foundation. Work through Servlets, JSPs, JSFs, JavaScript interaction, CDI, and EJB concepts. Produce a request-flow diagram and a deployable example. At the end of the week, explain how a request reaches business logic and how a managed component receives its dependencies.
Week two should focus on persistence and transactions. Study JPA and JTA, add entity operations to the application, and test success and rollback paths. Write down the boundary of each transaction and the expected entity state at each step. If you cannot explain why a persistence operation is valid in its context, return to the API and specification references rather than memorizing a workaround.
Week three should cover integration and platform services. Study JAX-RS, JAX-WS, JMS, WebSockets, Bean Validation, Batch API, Timer services, and Java EE Concurrency. Build narrow demonstrations rather than one complicated project. The objective is to distinguish purpose, lifecycle, communication style, and execution model for each capability.
The final phase should be diagnostic. Revisit only the topics marked unknown or can explain but cannot implement. Complete mixed design scenarios, review the official documentation, and perform a scheduling check using Oracle’s current exam page. Keep the original exam code and stated duration in your planning notes, but verify live operational details before registration.
What evidence should show that you are ready?
You are closer to readiness when you can map a requirement to a Java EE 7 technology, explain the component boundary, identify the relevant context or lifecycle, and describe what happens when the operation fails. You should also be able to read an unfamiliar but documented example and predict its broad behavior before testing it.
Use a three-column readiness sheet: concept, proof, remaining question. “Proof” might be a working lab, a written request trace, or a corrected explanation of a failed design. A blank proof cell is a study task. This method is more reliable than judging readiness by course completion alone, especially when the learning path has an approximate duration rather than an individual readiness guarantee.
Which mistakes waste the most preparation time?
The most expensive mistake is studying Java EE 7 as a catalogue of annotations without understanding component interaction. Candidates also lose time by trusting later-platform habits, skipping hands-on deployment, and treating every service technology as interchangeable. Correct these issues by anchoring each topic to a request, transaction, message, scheduled task, or batch step.
Do not use exam dumps, leaked questions, or memorization claims as a preparation strategy. They do not establish genuine platform knowledge and cannot guarantee a pass. Work from Oracle’s learning materials, documentation, and your own legitimate practice instead.
Do not invent a blueprint from informal percentages. The supplied official research contains no verified domain-weight table, so a plan that claims one topic is worth a particular percentage is unsupported here. If Oracle publishes weights with the current exam information, copy each percentage together with its exact domain label and use it only for prioritization.
Do not confuse a five-day instructor-led course with the separate online learning-path duration of approximately 18 hours and 23 minutes, or either duration with the stated 2-hour online exam duration. These are different subjects: classroom course, self-paced learning path, and exam. Keeping them separate prevents unrealistic scheduling.
Do not treat a successful tutorial deployment as proof that every Java EE 7 subject is covered. A web example may say little about JMS, batch processing, concurrency, SOAP, or transaction behavior. Maintain a coverage matrix and require at least one explanation or exercise for each official topic family.
How should you handle conflicting advice?
When a third-party article, workplace habit, or practice question conflicts with Oracle’s Java EE 7 documentation, identify whether the disagreement concerns version, vendor behavior, configuration, or an actual platform rule. Check the tutorial, API documentation, and platform specification in that order, then record the resolution. Avoid carrying an unverified shortcut into exam preparation.
What should you do in the final days before registration?
Use the final review to confirm coverage and logistics, not to begin a new technology from scratch. Re-read your component and transaction diagrams, rebuild the most important examples, and verify the official registration page. Oracle’s supplied learning path identifies 1Z0-900 and a 2-hour online exam duration, but current scheduling rules and candidate procedures must be checked at the time you register.
Prepare a concise comparison sheet for the distinctions most likely to blur together: JSP versus JSF, CDI bean versus EJB, JAX-RS versus JAX-WS, synchronous call versus JMS message, entity state versus transaction scope, and request processing versus batch or scheduled execution. Include purpose, lifecycle, boundary, and one limitation for each side.
On the day you schedule, confirm that your preparation evidence covers the full platform map rather than only the topics used in your job. If a major area remains only at recognition level, postpone the booking and make a targeted lab. If the gaps are limited to terminology or documentation lookup, finish those corrections before committing.
After registration, use the official exam information as the authority for any change to duration, delivery, requirements, or status. The supplied sources do not establish a current retirement date, price, score, question count, language, or test-day procedure, so none of those should be assumed from another Oracle credential.
Where should you verify the details?
Use Oracle’s certification learning path for the credential name, exam code, registration relationship, and the stated online exam duration. Use the Java EE 7 documentation hub for tutorials, APIs, installation guidance, release notes, and the platform specification. Use the Oracle training outline to structure topic coverage, while remembering that training coverage is not the same thing as a published exam blueprint.
The Oracle badge page is useful for confirming the credential’s stated capability and associated skill vocabulary, including EJB, CDI, JMS, JPA, JSF, JSP, Servlets, JAX-RS, JAX-WS, Web Services, and WebSockets. Recheck all time-sensitive registration information on Oracle rather than relying on an archived catalogue or a third-party summary.
Recommended next action: open the official learning path, copy the currently displayed objectives and registration instructions into your study tracker, then complete the baseline inventory before selecting a course or exam date.
Conclusion
The sensible route to Java EE 7 Application Developer certification is an evidence-based one: map the official topics, build connected Java EE 7 examples, verify behavior in Oracle documentation, and schedule 1Z0-900 only after your weak areas have practical proof. The supplied sources establish the credential’s purpose, exam code, online format and stated duration, but they do not support assumptions about price, score, question count, language, or current status. Confirm those details directly before registration.