IBM Notes and Domino 9.0 Social Edition Application Development B Exam Guide
The official IBM material identifies the related credential as IBM Certified Application Developer - Notes and Domino 9.0, for developers who use Domino Designer 9.0. It validates understanding of Domino application architecture, design elements, programming, debugging, performance, security, user management, XPages, and related technologies. IBM’s published sources do not provide a separate current exam guide or registration record specifically titled “Application Development B,” so use this guide to decide whether your preparation should focus on verified product skills, practical application building, or confirmation of the exact catalogue listing before scheduling.
What credential does the official IBM material identify?
IBM’s certification page names the credential IBM Certified Application Developer - Notes and Domino 9.0. It describes the intended candidate as an IBM Notes and Domino application developer who uses Domino Designer 9.0 and says candidates need a deep understanding of architectural concepts, complex functions, and product features.
The catalogue title supplied for this page includes “IBM Notes and Domino 9.0 Social Edition Application Development B.” That wording should not be treated as a verified IBM exam title without checking the current provider or catalogue record. The official IBM source located for the application developer credential does not publish a separate guide or current registration detail under that exact name.
This distinction matters before study begins. Confirm the exam identifier, availability, delivery method, and registration route with the organization offering the listing. Do not infer that a page title, a practice-test label, or the related Advanced Application Developer page proves that this exact exam is currently scheduled by IBM.
IBM’s separate Advanced Application Developer - Notes and Domino 9.0 page says that certification was withdrawn on November 30, 2019. That fact applies to the advanced certification named on that page; it does not establish the status of the application developer credential or of the catalogue title used here.
Who should use this preparation plan?
This plan fits developers who design or maintain Notes and Domino applications in Domino Designer 9.0, especially those responsible for data structures, forms and views, XPages, security, integration, debugging, and performance. It is also useful for experienced developers who need to translate product experience into structured certification revision.
IBM’s profile is not aimed only at people who can edit an existing form. It expects a deep understanding of how Notes and Domino applications are architected and how complex functions and features work together. Your preparation should therefore test design reasoning, not just whether you remember individual menu commands.
A candidate moving from classic Notes development into XPages should give extra attention to the relationship between the Domino database, design elements, client or browser access, and presentation technologies. A candidate already comfortable with XPages should not neglect security, user management, integration, debugging, or performance simply because those areas are less visible in a user interface.
Use the guide as a planning aid rather than as evidence of exam availability. The official pages supply the skills profile and product documentation; they do not supply live questions, a current blueprint for an exam titled Application Development B, or a promise that completing any particular study sequence will result in a pass.
What skills does IBM associate with the credential?
IBM identifies Application Architecture, Application Debugging, Application Design Elements, and Application Performance as key areas of focus. It also lists Extension Library, IBM Domino Designer and Eclipse, Integrating External Data, Programming, Security Features, User Management, and XPages.
The technology profile specifically names XPages, CSS, XML, and JavaScript. Treat these as connected skills rather than isolated vocabulary. For example, an XPages feature may involve page structure, styling, client-side behavior, server-side logic, access control, and the way data is exposed by the underlying Domino application.
The listed domains suggest that a strong candidate should be able to explain why an application is structured in a particular way, identify where a fault is likely to originate, select an appropriate design element, and consider the operational effect of a design or programming choice. They also point to the need to distinguish browser-facing behavior from Notes-client behavior.
IBM does not publish percentages for these domains in the supplied official material. Consequently, there is no evidence-based weighting to use for a percentage-based study schedule. Allocate time according to your experience, the complexity of the work you perform, and the areas in which you cannot yet explain or demonstrate a complete solution.
Application Architecture
Start with the database as the application foundation. IBM states that every Domino application begins with a Domino database containing the application’s data, logic, and design elements, and that an application may consist of one or more Domino databases. Revise architecture as a set of relationships, not as a list of object names.
Application Debugging
Prepare to trace a problem from the visible symptom to the responsible layer. Separate data, design, server-side logic, client-side behavior, browser behavior, permissions, and integration boundaries when investigating a fault. Build this habit with controlled examples rather than memorizing supposed question answers.
Application Design Elements
Review how the application’s stored data, logic, and design are represented and how a chosen element supports a user task. Your notes should explain the purpose of each element you use and the consequences of changing it, including effects on navigation, data retrieval, validation, and maintenance.
Application Performance
Study performance as a design concern. Examine how data access, rendering, scripting, integrations, and unnecessary work can affect an application. Record the evidence you would collect before changing a design, because a performance fix selected without identifying the bottleneck can simply move the problem to another layer.
Extension Library and Eclipse
IBM lists Extension Library and IBM Domino Designer and Eclipse among the focus areas. Learn their role in the development environment and in application construction, then connect that knowledge to the specific application behavior produced. Avoid treating product names alone as proof that you understand when a feature is appropriate.
Integrating External Data
Prepare to reason about the boundary between Domino data and external data. Define what the application owns, what it reads or updates elsewhere, how failures are handled, and how security is preserved. Use documentation-led exercises and do not assume that an integration choice is suitable merely because it is technically possible.
Programming
Review the programming techniques used in the application environment and relate them to lifecycle, data access, validation, error handling, and maintainability. Include the interaction between server-side and client-side behavior where relevant. A useful study note explains not only how code works, but also where it executes and what it can affect.
Security Features and User Management
Treat security and user management as application behavior, not administrative afterthoughts. Map users, roles, permissions, protected data, and authorization decisions to the application design. Test both an allowed and a denied path in a safe environment so that your explanation includes the reason for the result.
XPages, CSS, XML, and JavaScript
The IBM profile names XPages, CSS, XML, and JavaScript. Study them in context: XPages for application presentation and behavior, CSS for presentation rules, XML for structured representation or configuration where applicable, and JavaScript for client-side or related application logic. Verify every product-specific detail against the Domino Designer documentation.
How does a Domino application serve Notes and web users?
IBM says Domino Designer can create one application for both an intranet and the Internet. The underlying database structure remains the same whether users access the application through the Notes client or a web browser, although IBM explains that a web database differs in its viewing mechanism because web users access it through a browser.
This is a useful architectural anchor for revision. Do not describe Notes-client and browser access as two unrelated applications by default. Instead, identify the shared database foundation and then examine the presentation, interaction, authentication, scripting, and design considerations that differ between the access paths.
Build a small comparison table in your own notes with four columns: shared foundation, Notes-client behavior, browser behavior, and risks or tests. Populate it from IBM documentation and your own controlled development work. This forces you to explain what remains constant and what must be verified separately.
A common mistake is to assume that successful behavior in the Notes client automatically proves browser compatibility. Test the intended access path, inspect the relevant design and code, and record any dependency on client-specific behavior. The official documentation supports the shared structure; it does not remove the need to validate each user interface.
What should you practise in Domino Designer?
Use Domino Designer as a working laboratory, not just a reading subject. IBM describes it as an integrated application development environment for creating, managing, and deploying secure interactive applications, and its Social Edition documentation focuses on creating applications with XPages technology.
The documentation also describes Domino Designer 9.0.1 Social Edition as a no-charge application development environment. That makes a controlled practice environment a sensible recommendation where your organization permits it, but availability of a suitable server, client, sample data, or compatible setup is not established by the supplied sources.
Create a deliberately small application with a clear purpose. Begin with its database foundation and design elements, then add a user-facing path, validation, access rules, and an observable diagnostic or performance concern. Keep a record of each change and the reason for it. The aim is to develop explainable decisions, not to produce a large portfolio project.
Use separate exercises for classic and XPages-oriented behavior if both are relevant to your work. Compare how the same business requirement is represented, rendered, validated, and secured. This comparison exposes gaps that passive reading often hides, especially around client versus browser behavior and the location of application logic.
Do not use copied exam questions, dumps, or leaked material as a substitute for practice. Such material cannot establish that you understand the architecture, may be inaccurate or outdated, and does not provide a reliable way to reason through an unfamiliar scenario.
How should you sequence the study?
Study in dependency order: establish the Domino application model, build design-element knowledge, add programming and XPages, then test security, integration, debugging, and performance across the resulting application. This sequence gives later topics a concrete foundation and prevents isolated memorization.
Begin with architecture and design elements. Write a one-page map showing where data, logic, and design reside in your practice application and whether the application uses one database or more than one. Then explain how the same database foundation supports the intended Notes-client and browser access paths.
Next, work through XPages and the named web technologies. For every exercise, identify the markup or page structure, styling, client-side behavior, server-side behavior, data source, and validation path. Keep CSS, XML, and JavaScript notes tied to an actual outcome rather than a dictionary definition.
Add security and user management before integration. Determine which users should see, edit, or administer each function, then test the boundaries. After that, introduce an external-data scenario or integration design and document timeout, unavailable-data, authorization, and error-handling decisions without assuming an undocumented implementation detail.
Finish with debugging and performance drills. Break one known behavior at a time, observe the symptom, isolate the layer, and restore the application. For performance, establish what is slow or wasteful before proposing a change. This final phase turns the earlier topics into diagnosis and decision-making skills.
A four-stage roadmap
Stage one is orientation. Confirm the exact catalogue entry and gather the IBM certification profile and Domino Designer documentation. Mark each listed focus area as strong, developing, or unknown. Do not spend study time on a supposed exam domain that cannot be connected to the official profile or your role.
Stage two is construction
Stage two is application construction. Build or inspect a small application from its database foundation through its design elements and user-facing behavior. Keep an implementation journal containing the requirement, selected feature, expected result, observed result, and any constraint that changed the design.
Stage three is investigation
Stage three is investigation. Use faults, permission changes, invalid data, unavailable dependencies, and inefficient operations to practise debugging and performance analysis. For each case, state the evidence you would collect and the smallest defensible change you would make.
Stage four is verification
Stage four is verification. Revisit every IBM-listed area and explain it without looking at notes, then validate uncertain product details in the official documentation. Only after confirming the exact exam’s registration and delivery information should you make a scheduling decision.
How can you measure readiness without an official percentage blueprint?
Use capability checks instead of invented domain weights. IBM’s supplied certification page names the focus areas but provides no percentages for them, so a readiness review should ask whether you can explain, implement, test, and troubleshoot each area rather than assigning unsupported numerical importance.
For architecture, draw the application boundary and explain the role of each database. For design elements, identify what supports each user task. For XPages and related technologies, trace a visible result to the responsible code or configuration. For security, show why two user contexts receive different outcomes.
For debugging, start from a symptom and list competing causes before changing code. For performance, state what evidence would confirm the bottleneck. For integration, describe ownership, data flow, authorization, and failure behavior. For user management, connect identity and permissions to the actual application path.
A useful self-test has three passes. First, explain the concept aloud or in writing. Second, perform a small controlled implementation. Third, alter one condition and predict the result before testing it. If your explanation and prediction disagree with observation, return to the documentation and record the corrected rule.
Readiness is not the same as familiarity with a practice-test score. A candidate who recognizes terminology but cannot justify a design choice still has a material gap. Conversely, a candidate who can build and diagnose a feature may need only targeted terminology review, subject to the exact requirements of the exam listing.
Which documentation should anchor revision?
Use IBM’s certification profile to define the topic boundary and IBM’s Domino Designer documentation to confirm how the product is described and used. The supplied official sources support architecture, application creation, the development environment, application design, and the named certification focus areas.
The application-creation documentation states that all Domino applications begin with a Domino database containing data, logic, and design elements. It also explains that an application may consist of one or more Domino databases, can support intranet and Internet use, and retains the same database structure for Notes-client and browser access.
The Domino Designer user guide describes the 9.0.1 Social Edition environment as a no-charge application development environment and focuses on creating applications with XPages technology. Use that guide to structure hands-on reading, but confirm that any detail you rely on is relevant to the product version and exact exam listing you are considering.
The application-design reference describes Domino Designer as an integrated environment for creating, managing, and deploying secure interactive applications. This supports a broad view of the tool: revision should include construction, management, deployment considerations, and security-related design decisions rather than only page editing.
Keep a source log. For each uncertain statement, record the IBM URL, the product or credential it describes, and the practical decision it affects. This prevents accidental transfer of information from the advanced certification page, an unrelated version, or an unofficial practice source.
What mistakes can waste preparation time?
The largest avoidable mistake is preparing for an assumed blueprint. The official material supplied here does not publish percentages, question counts, duration, languages, price, prerequisites, or current registration details for a separately titled Application Development B exam. Treat those items as unverified until the official or authorized registration source confirms them.
Another mistake is studying XPages alone. XPages is prominent in the supplied documentation and is one of IBM’s listed focus areas, but the profile also names architecture, debugging, design elements, performance, integration, programming, security, user management, Extension Library, and Domino Designer and Eclipse.
Do not reduce architecture to a definition of a Domino database. Use the database foundation to reason about data, logic, design elements, multiple-database applications, and the different viewing mechanisms used by Notes-client and browser users. A definition without an applied model will not prepare you for a design decision.
Avoid changing several variables during a debugging exercise. If code, permissions, data, and page structure all change at once, you cannot tell which change produced the result. Isolate the fault, capture the evidence, make one controlled change, and retest the original path.
Do not assume that a technically elegant feature is automatically appropriate. Consider maintainability, user access, data ownership, failure handling, and performance. Certification preparation is stronger when you can explain trade-offs and constraints, not merely demonstrate that a feature exists.
Finally, do not schedule solely because a catalogue page uses a familiar IBM product name. First confirm the exact credential, exam identifier, availability, delivery arrangement, and current rules through the relevant official or authorized channel. Those details are not established by the supplied IBM research.
What should you confirm before scheduling?
Before scheduling, verify that the exam provider’s title and identifier correspond to the credential you intend to pursue. The IBM page supplied for the application developer credential uses the name IBM Certified Application Developer - Notes and Domino 9.0, while the supplied research does not document a separate official exam guide titled Application Development B.
Confirm current availability and registration instructions at the point of scheduling. The provided sources do not establish a current delivery method, test-center or remote option, appointment process, fee, exam duration, question count, language list, passing score, prerequisite, or cancellation rule for this catalogue title.
Ask the provider to clarify whether “B” identifies a version, section, delivery form, internal catalogue variant, or another assessment. Do not fill that gap with assumptions from a practice site or from the Advanced Application Developer page, whose withdrawal statement concerns a different certification.
Save the confirmed registration page and compare its scope with the IBM certification profile. If the provider cannot explain the relationship between the listing and the official credential, pause scheduling and seek clarification. A short verification step is more useful than committing preparation time to the wrong assessment.
Once the identity and logistics are confirmed, set a study checkpoint rather than an unsupported calendar promise. At that checkpoint, review your capability matrix, complete a controlled application exercise, and decide whether remaining gaps are narrow enough for targeted revision or broad enough to require more development practice.
What are the next actions for a serious candidate?
Start by recording the exact catalogue wording and asking the provider for the authoritative exam identifier and current registration information. Then download or consult the supplied IBM certification and Domino Designer pages, map their topics to your work, and create a practice application that gives each major skill a visible test.
On your first study session, write the application architecture and identify its databases, data, logic, and design elements. On the next, trace one user task through its presentation, data access, validation, and security path. Continue by introducing a controlled fault, an access restriction, and a performance question, documenting what you observe.
At the end of each session, write two notes: one product rule supported by IBM documentation and one practical uncertainty that still requires verification. This keeps evidence separate from personal preference and prevents catalogue assumptions from becoming study facts.
Before booking, complete a source-based review of all listed focus areas: Application Architecture, Application Debugging, Application Design Elements, Application Performance, Extension Library, IBM Domino Designer and Eclipse, Integrating External Data, Programming, Security Features, User Management, and XPages. Include CSS, XML, and JavaScript where they affect the application behavior you are studying.
The final decision should be evidence-led. Schedule only after the exact assessment and its current logistics are confirmed, and continue practising until you can justify design, security, integration, debugging, and performance decisions in your own words. No unofficial question collection can replace that level of product understanding.
Conclusion
The verified IBM material supports preparation around Domino application architecture, design elements, programming, XPages and related technologies, security, user management, integration, debugging, and performance. It does not verify a separate current exam guide or registration record for the title Application Development B, nor does it provide a percentage blueprint or delivery details for that listing. Confirm the assessment identity first, then use a small working application and documentation-led troubleshooting exercises to turn the published skills profile into practical readiness.
