IBM Notes and Domino 9.0 Social Edition Application Development B: Exam Guide
This guide treats “IBM Notes and Domino 9.0 Social Edition Application Development B” as a catalogue label that must be checked against IBM’s official certification records before you schedule anything. IBM’s available certification page names the credential IBM Certified Application Developer - Notes and Domino 9.0, for developers using Domino Designer 9.0, and emphasizes architecture, design, debugging, performance, programming, security, user management, external data, Eclipse, Extension Library, and XPages. Use this guide to decide whether your preparation should focus on hands-on application construction, conceptual review, or first confirming the exam’s current identity and availability.
What IBM officially identifies—and what remains unverified
The strongest official match is IBM Certified Application Developer - Notes and Domino 9.0. IBM’s located sources do not publish a separate exam guide or current registration detail specifically titled “IBM Notes and Domino 9.0 Social Edition Application Development B,” so verify the exact exam name, code, availability, and registration route with IBM before committing to a study plan or purchase.
Use the certification page as the scope anchor
IBM says the credential is intended for IBM Notes and Domino application developers who use Domino Designer 9.0. The same page says candidates need a deep understanding of Notes and Domino architectural concepts and complex functions and features. That description supports a preparation plan built around design reasoning and implementation decisions, not vocabulary memorization alone.
Do not confuse this listing with the advanced certification
IBM separately states that its Advanced Application Developer - Notes and Domino 9.0 certification was withdrawn on November 30, 2019. That fact applies to the advanced certification page, not automatically to the application developer credential or to the catalogue label used for this article. Treat the two records as separate until IBM confirms otherwise.
Make verification your first scheduling decision
Before scheduling, open the official application developer page and look for the current exam identification and registration information. If the page does not resolve the “Application Development B” label, contact the relevant IBM certification channel or training provider. Do not infer a live exam, delivery method, price, duration, language, score, or question count from a third-party listing.
Who should use this preparation path
This path fits a developer who can work with Domino Designer and wants to validate application-development judgment across the Notes and Domino platform. It is less suitable as a first exposure to the product: IBM’s wording points to deep architectural knowledge and complex functions, so a candidate should first establish whether they can build, explain, debug, secure, and improve a Domino application.
A useful readiness test
Ask whether you can explain how an application’s data, logic, and design elements fit together; distinguish Notes-client access from browser access; trace a design or code problem; and reason about security, users, external data, and performance. These are preparation checks, not IBM-published pass criteria. A “no” answer identifies a study topic rather than a reason to guess on exam scope.
Choose study depth based on your work pattern
A developer who primarily maintains classic Notes applications should deliberately add XPages, JavaScript, CSS, XML, and Extension Library review. Someone whose recent work is mostly browser-oriented should revisit database structure, Notes and Domino architecture, security, user management, and the underlying design elements. IBM lists all of these areas or technologies in the certification profile.
Separate product familiarity from assessment readiness
Knowing where a Domino Designer feature is located is not the same as understanding when to use it or how it affects deployment, access, debugging, and performance. During preparation, explain each design choice in writing and test it in a small application. That exercise exposes gaps that a passive reading session can hide.
What the certification profile measures
IBM names four central areas: Application Architecture, Application Debugging, Application Design Elements, and Application Performance. It also lists Extension Library, IBM Domino Designer and Eclipse, Integrating External Data, Programming, Security Features, User Management, and XPages. IBM does not provide percentage weights in the supplied sources, so allocate time by weakness and breadth rather than inventing a weighted blueprint.
Application Architecture
Architecture preparation should begin with the Domino database as the application’s foundation. IBM states that every Domino application begins with a Domino database containing its data, logic, and design elements, and that an application may consist of one or more Domino databases. Study how those pieces cooperate and why an application might be organized across databases.
Application Design Elements
Review the design elements that turn stored data into an application users can navigate and operate. The goal is not to memorize isolated names; it is to connect a user need to an appropriate design decision, then consider how that decision behaves in a Notes client and through a browser. Use IBM’s application-design documentation as the reference vocabulary.
Application Debugging
Debugging preparation should follow a repeatable path: reproduce the problem, isolate whether it is data, design, code, access, or rendering, inspect the relevant layer, make one controlled change, and retest. Keep a short fault log while studying. Record the symptom, likely layer, evidence, correction, and regression check so that debugging becomes an analysis skill rather than a list of remembered fixes.
Application Performance
Performance study should connect implementation choices to user-visible behavior. Examine where data is retrieved, how much work occurs during an interaction, whether a design is doing unnecessary processing, and whether security or external integration changes the cost. IBM identifies Application Performance as a focus area, but the supplied sources do not define a detailed performance blueprint or scoring weight.
Programming and web technologies
IBM specifically lists XPages, CSS, XML, and JavaScript among the technologies covered by the profile. Review their roles in an application rather than treating them as unrelated subjects: identify which layer handles presentation, behavior, data exchange, or application logic, and trace how a change in one layer affects the others.
Security and user management
Security preparation should be scenario-based. For each application feature, ask who can see, create, edit, approve, or administer the information, and where that decision is enforced. Pair security review with user-management review so that identity, access, and application behavior are considered together rather than as separate memorization topics.
External data, Eclipse, and Extension Library
IBM lists Integrating External Data, IBM Domino Designer and Eclipse, and Extension Library as focus areas. Build a concise comparison sheet for each: purpose, place in the development workflow, dependencies, likely failure points, and the evidence you would inspect when something does not work. Avoid inventing specific supported integrations or version behavior unless the documentation confirms it.
How Domino application structure affects your reasoning
A Domino application is not merely a collection of screens. IBM states that its database contains data, logic, and design elements, and that one application may use one or more Domino databases. Use that model as the starting point for every practice task: identify the data boundary, the design boundary, the logic boundary, and the users’ access path before selecting an implementation.
Build one small application as a study laboratory
Create a deliberately modest application in a suitable Domino Designer environment, using the official documentation to confirm setup and feature behavior. Give it a clear data model, a user-facing workflow, a browser access path, and at least one administrative or security decision. The purpose is controlled practice, not reproducing a supposed live exam question.
Trace the same feature through multiple layers
Choose one feature such as a searchable record, approval action, or user-specific view. Document its stored data, design elements, programmed behavior, presentation rules, access controls, and performance implications. Then change one assumption—such as browser access or a different user role—and explain what must change. This produces the cross-domain reasoning IBM’s focus areas require.
Use the Notes client and browser distinction correctly
IBM explains that a web database differs by its viewing mechanism: users access it through a web browser instead of the Notes client. IBM also states that the database structure is the same whether users access the application through the Notes client or a browser. Study both statements together. They support a useful question: which part of the application remains shared, and which behavior depends on the viewing mechanism?
Keep platform claims within the evidence
IBM states that Domino Designer can create one application for both an intranet and the Internet. That does not by itself establish every deployment rule, compatibility condition, or security setting. When your notes go beyond this principle, mark them for confirmation in the relevant product documentation instead of presenting a remembered rule as an official exam requirement.
A practical study sequence that avoids shallow coverage
Study in dependency order: first establish the Domino application model, then design elements and architecture, then programming and XPages, followed by security, user management, external data, debugging, and performance. Revisit the topics through one working application. This sequence gives later subjects a concrete system to act upon instead of leaving each domain as an isolated reading assignment.
Stage one: establish your baseline
Write down the exact exam title shown by the catalogue, the official IBM credential it appears to reference, and every registration detail that still needs confirmation. Then list the product features you have used recently, the features you can explain but have not built, and the features you recognize only by name. This prevents time being spent equally across unequal gaps.
Stage two: map the application
Read IBM’s application-creation and application-design material while drawing your own architecture map. Show databases, stored information, design elements, logic, user paths, and browser or Notes-client access. For each box, write one sentence explaining its responsibility and one sentence describing a likely defect. This converts documentation into retrieval practice.
Stage three: implement and inspect
Use Domino Designer to implement the smallest useful version of your map. Add a controlled change after the first version works: a role, a browser interaction, an external-data boundary, or a performance-sensitive operation. Inspect the result from the viewpoint of a developer, user, and administrator. Keep the implementation small enough that you can explain every part.
Stage four: debug deliberately
Introduce safe, reversible faults into your practice application, such as an incorrect assumption about data, an access mismatch, or a presentation and behavior inconsistency. Diagnose each fault from evidence. Do not rely on a memorized “fix” until you can state why the fix addresses the actual layer and what new risk it could introduce.
Stage five: consolidate with retrieval questions
Close the documentation and answer questions in your own words: What is the application’s data boundary? How does browser access differ from Notes-client access? Which design or code layer owns this behavior? What evidence would isolate the defect? Who should have access? What could make the interaction slow? Correct answers with IBM documentation, and label any practical inference as your own study conclusion.
A four-week roadmap with adjustable pacing
A four-week plan is a planning example, not an IBM requirement. Adjust it to your experience and to the official exam details after verification. The important feature is the sequence of build, explain, test, and review—not the calendar. If the exam cannot be confirmed as currently available, use the roadmap for skills development and postpone scheduling until the official record is clear.
Week one: architecture and design vocabulary
Start with IBM’s documentation on creating applications and application design. Build the architecture map, identify the data and design boundaries, and create a glossary in your own words. End the week by explaining how one application can involve one or more Domino databases and how shared database structure relates to different viewing mechanisms.
Week two: implementation and programming
Work through a small application with a browser-facing use case. Review the roles of XPages, JavaScript, CSS, and XML as they appear in the certification profile. Add one controlled design change each study session and record its effect. If you cannot run a feature, study its documented purpose and mark hands-on verification as an outstanding task.
Week three: security, integration, and troubleshooting
Review Security Features, User Management, Integrating External Data, Extension Library, and IBM Domino Designer and Eclipse. Use a decision table with columns for user, action, data, enforcement point, dependency, and diagnostic evidence. Practice explaining what you would inspect when an authorized user cannot complete an action or when an integrated feature behaves unexpectedly.
Week four: performance and mixed review
Combine all domains in short design reviews. For each scenario, state the architecture, design elements, programming layer, access model, likely performance concern, and debugging evidence. Finish by checking official certification and registration information again. Schedule only when the exact exam identity and current delivery details are confirmed through an authoritative source.
If your available time is shorter
Prioritize architecture, design elements, XPages and programming, security, and debugging because they connect several of IBM’s named focus areas. Do not drop performance, user management, external data, Eclipse, or Extension Library entirely; create a one-page purpose-and-risk summary for each. A compressed plan should narrow implementation scope, not pretend that omitted domains are irrelevant.
Study materials and how to use them
Use IBM’s certification page to define the profile and IBM Domino Designer documentation to understand the product concepts behind it. Read for decisions, then verify those decisions in a controlled exercise where possible. A source is most useful when it answers not only “what is this feature?” but also “what problem does it solve, what does it depend on, and how would I diagnose it?”],
subsectionsets? []},{
Conclusion
The practical next step is to verify the catalogue label against IBM’s official certification record before making a scheduling decision. Once the target is confirmed, prepare around the documented focus areas: architecture, design elements, debugging, performance, programming, XPages, security, user management, external data, Extension Library, and the Designer and Eclipse environment. Build and explain a small application, test both browser and Notes-client access where your environment permits, and use documentation to resolve uncertainty. Treat unofficial question collections as unverified study material; memorizing recalled questions cannot establish the underlying skills or guarantee a pass.
