IBM Notes and Domino 9.0 Social Edition Application Development A Exam Guide
This exam is best approached as a validation of practical Notes and Domino application-development knowledge: architecture, design elements, programming, security, debugging, performance, user management, and XPages. IBM’s official credential for this subject is titled “IBM Certified Application Developer - Notes and Domino 9.0,” intended for developers using Domino Designer 9.0. This guide helps you decide whether your preparation should begin with platform fundamentals, concentrate on XPages and web development, or pause until you verify current registration and delivery information through IBM’s official certification page.
What credential does this exam relate to?
The requested catalogue label refers to the Notes and Domino 9.0 application-development track, while IBM’s official page names the matching credential “IBM Certified Application Developer - Notes and Domino 9.0.” Treat the catalogue wording as an identifier, then use IBM’s page to confirm the current status and applicable registration information before scheduling.
Use the official credential page as the authority
IBM identifies the credential as intended for IBM Notes and Domino application developers using Domino Designer 9.0. IBM also says candidates need a deep understanding of Notes and Domino architectural concepts and complex functions and features. Those statements support a preparation plan based on building and reasoning about applications, not memorizing isolated terminology.
Do not confuse the advanced listing with this target
IBM separately lists “IBM Certified Advanced Application Developer - Notes and Domino 9.0.” IBM states that this advanced application-developer certification was withdrawn on November 30, 2019, and its page identifies credential code 14003206 with the required exam shown as “N/A.” That page is useful for distinguishing advanced subject areas, but it does not establish current availability for the application-developer credential.
What skills should your preparation cover?
Build your study plan around the official focus areas: Application Architecture, Application Debugging, Application Design Elements, Application Performance, the Extension Library, IBM Domino Designer and Eclipse, Integrating External Data, Programming, Security Features, User Management, and XPages. These areas form a more useful checklist than a generic review of Notes terminology.
Start with architecture and design elements
First understand how an application is organized and how its parts cooperate. Review databases, forms, views, documents, agents, navigation, design inheritance, and the relationship between client-facing and web-facing behavior. The official source does not provide a detailed question-by-question blueprint here, so use these topics as a practical foundation rather than claiming that every listed subtopic has a separate exam allocation.
Treat programming as an application decision
Review formulas, LotusScript, JavaScript, and the way code interacts with documents, views, events, and security boundaries. IBM specifically lists XPages, CSS, XML, and JavaScript among the technologies associated with the credential. Study each technology in context: identify where it runs, what data it can access, and what maintenance or security consequence follows from choosing it.
Include security and user management early
Security should not be left until the final review because it affects architecture, design, testing, and deployment. Examine how users and groups are represented, how access is controlled, and how application behavior changes for different identities. Use controlled practice accounts and nonproduction data so that experimentation does not alter a real directory or business application.
How should you use Domino Designer documentation?
Use the Domino Designer documentation to connect the product environment with the work you are expected to understand. IBM describes Domino Designer as an integrated application-development environment for creating, managing, and deploying secure, interactive applications, and its 9.0.1 documentation says the environment focuses on creating applications with XPages technology.
Read for relationships, not isolated definitions
When reading documentation, trace a complete development path: create or inspect a design element, connect it to data, add behavior, test the result, and consider how it is secured and deployed. For every feature, write down its purpose, inputs, outputs, dependencies, and likely failure points. This turns reference reading into decisions you can reproduce in a development environment.
Use the user guide as a navigation map
The Domino Designer user guide can help you locate product concepts and XPages material, but it should not be treated as a substitute for hands-on work. Select a small application and use the guide to answer specific questions about its design. Record the source section and the result of your test, especially when a feature behaves differently in client and browser contexts.
Handle older product material carefully
IBM’s product-documentation links page directs readers seeking older Lotus or developerWorks material toward IBM Documentation, Lotus product documentation, IBM Support, IBM Fix Central, Passport Advantage Online, IBM Training, and IBM Community. Use those routes to locate supporting material, but verify that a page applies to the Notes and Domino 9.0 development context before making it part of your revision set.
What practical project should you build while studying?
Create a small multi-feature application that forces you to combine design, code, data, security, and troubleshooting. A request-tracking application is suitable: users submit documents, managers review them, a view supports status filtering, and a browser-oriented page presents the workflow. The value is not the business theme; it is the number of technical decisions you can explain and test.
Build the minimum data and navigation model
Define the documents and fields first. Add forms for creation and editing, views for retrieval, and navigation that makes the user’s next action obvious. Then document why each field exists, which design element owns its behavior, and what happens when a value is missing or changed. This exposes weak assumptions before you add advanced presentation features.
Add XPages after the underlying model works
Use XPages to create a usable interaction over the data model, then introduce CSS, XML, and JavaScript only where they solve a defined presentation or behavior requirement. IBM’s documentation emphasis on XPages makes it a sensible practical area, but avoid building a visually elaborate interface that leaves data access, validation, and authorization unexplained.
Test more than the successful path
Test a new document, an edit, an invalid value, a missing document, a user without the required access, and a request that moves through each workflow state. Compare behavior in the relevant client or browser context. Keep a defect log containing the symptom, probable layer, diagnostic evidence, correction, and regression test. That log becomes a high-value revision tool.
How should you sequence the study topics?
Study in dependency order rather than following a random list. Begin with architecture and design elements, move into programming and XPages, then add security, user management, external data, debugging, and performance. Revisit the earlier layers after each new feature because integration failures often come from an incorrect boundary between design, code, data, and access control.
Phase one: establish the platform model
Map the application lifecycle from design through deployment. Identify the role of databases, documents, forms, views, agents, and application navigation. Review how Domino Designer organizes development work and how an application’s design can support both interactive use and administration. End this phase by explaining your sample application without opening the code.
Phase two: connect behavior to data
Implement common document operations and retrieval patterns, then practice formulas, LotusScript, and JavaScript in the places where they are appropriate. Add an XPages interface and inspect how controls, events, validation, and data sources interact. Your checkpoint is a working feature whose execution path you can describe from user action to stored result.
Phase three: add integration and protection
Study how an application can access Domino and non-Domino data sources, then consider authentication, authorization, and exposure of data through the user interface. The advanced IBM listing names access to Domino and non-Domino data sources, workflow functionality, XPages functionality, and security implementation as recommended skills; these are useful stretch topics for strengthening an application-developer foundation.
Phase four: diagnose and optimize
Introduce deliberate defects such as an incorrect data binding, an invalid formula assumption, an authorization mismatch, or an inefficient retrieval path. Diagnose each defect using a repeatable process instead of guessing. Then review application performance: identify what is expensive, what evidence would confirm the problem, and which change would improve it without weakening correctness or security.
How can you turn the official focus areas into practice tasks?
Convert every focus area into an observable task and an explanation. For example, “Application Debugging” becomes reproducing a defect and isolating its layer; “Application Performance” becomes identifying a slow operation and proposing an evidence-based change; “Integrating External Data” becomes describing the source, access path, failure behavior, and security implications.
Use a two-column skills ledger
In the first column, list the IBM focus area or technology. In the second, record what you can build, what you can explain, and what remains uncertain. Mark a topic as ready only when you can complete a small task and explain an alternative design. This prevents passive reading from being mistaken for application-development competence.
Write comparison notes with conditions
Avoid notes that say one feature is simply “better.” Instead record the condition under which a choice is suitable. Compare implementation locations, data-access approaches, client or browser behavior, maintenance burden, and security exposure. Conditional explanations are more useful than slogans because application questions often depend on context.
Use the Extension Library as a focused investigation
IBM lists the Extension Library among the credential’s focus areas. Investigate what capability a selected extension provides, how it is configured, what dependencies it introduces, and how you would test its failure behavior. Keep the investigation bounded: mastering one feature’s lifecycle is more useful than collecting a long list of names without implementation evidence.
What mistakes commonly weaken preparation?
The most damaging preparation error is studying the product as a collection of labels. Candidates also lose time by ignoring security until the end, practicing only the happy path, and treating an old practice question or unofficial dump as authoritative. Build and test instead; no collection of leaked or memorized questions can establish reliable application-development understanding or guarantee a pass.
Do not memorize without tracing execution
If you memorize a definition, immediately attach it to a design element, data operation, event, or deployment decision. Ask what triggers the behavior, where it runs, what identity it uses, and what happens when its dependency is unavailable. If you cannot answer those questions, the topic needs practical work rather than another round of rereading.
Do not treat security as a final chapter
A late security review can reveal that your sample application exposes data or assumes permissions it does not have. Add restricted users and groups during development, test denied actions, and document expected outcomes. This makes security part of the design model and gives you concrete evidence for troubleshooting access-related defects.
Do not overfit to unofficial exam claims
The supplied IBM material identifies focus areas and recommended skills but does not provide a verified question count, passing score, exam duration, delivery format, language list, or blueprint percentages. Do not rely on websites that assert such details without an official source. Check IBM’s certification page for current scheduling information before making a booking decision.
How should you decide whether to schedule?
Schedule only after you can demonstrate the core work without following a step-by-step recipe. You should be able to inspect an unfamiliar application, identify its major design elements, explain its data flow, locate likely security boundaries, and propose a debugging path. If your knowledge is mainly conceptual, continue with the project and use documentation to close specific gaps.
Use a readiness review instead of a confidence score
Review each official focus area and classify it as demonstrated, explainable, or untested. “Demonstrated” means you completed a small task; “explainable” means you can describe the design and trade-offs; “untested” means you have only read about it. Schedule after the untested list is short and does not contain architecture, programming, security, XPages, debugging, or performance fundamentals.
Verify administrative details immediately before booking
The supplied research does not establish current exam delivery details, registration options, pricing, duration, question count, passing score, or availability. Confirm those items directly on IBM’s official certification page rather than inferring them from the product documentation or from the withdrawn advanced credential page. If the catalogue label differs from IBM’s title, verify that the code and credential are the intended match.
What is a practical final-week review plan?
Use the final review to retrieve and apply knowledge, not to begin an unrelated technology. Rebuild the application’s critical path, diagnose selected defects, test access differences, and explain design choices aloud or in writing. Keep documentation available for verification, but first attempt each task from your own model so that gaps remain visible.
Consolidate the architecture map
Draw the application’s data, design, code, interface, security, and deployment relationships on one page. Annotate where an action begins, how it reaches data, which identity is involved, and where an error could arise. Use the map to select targeted documentation searches instead of browsing broadly.
Run a mixed practice session
Alternate tasks from different areas: inspect a design element, modify a small behavior, diagnose a failure, review an access rule, and explain a performance concern. Mixing topics tests whether you can choose the relevant concept under pressure. It also reveals whether you understand the connections between the official focus areas rather than each area in isolation.
Prepare a source and question log
Keep a short list of unresolved questions, the IBM page or documentation section consulted, the answer you verified, and the test that confirmed it. Remove questions that are answered and isolate those requiring further practice. This provides a disciplined stopping point and reduces last-minute revision driven by unsupported forum claims.
What should you do next?
Begin by confirming the official credential identity and current administrative details, then inventory your experience against IBM’s focus areas. Set up a small application, establish its data and design model, and add one tested feature at a time. Use the official documentation for precise product behavior and treat every uncertainty as a testable research task rather than a reason to guess.
A focused action checklist
Verify the IBM credential page and the catalogue-to-credential match.
Create a skills ledger covering architecture, design elements, programming, security, user management, XPages, debugging, performance, external data, and the Extension Library.
Build and test a small application with both normal and denied-use cases.
Record defects, evidence, corrections, and regression checks.
Confirm current scheduling and delivery information with IBM before booking.
Stop using any preparation source that cannot be traced to official documentation or a clearly identified practical exercise.
Conclusion
The strongest preparation decision is to measure demonstrated capability, not the amount of material read. IBM’s published focus areas point toward an integrated developer who can reason about Domino architecture, create and modify application features, work with XPages and related technologies, protect data, and troubleshoot behavior. Build that evidence in a controlled project, verify uncertain administrative details on IBM’s current certification page, and use the documentation to resolve specific technical questions.
