IBM Notes and Domino 9.0 Social Edition Application Development Update Exam Guide
This exam validates the application-development knowledge needed to design, build, debug, secure, and improve Notes and Domino applications with Domino Designer 9.0. It serves developers who work across traditional Notes applications, web-enabled Domino solutions, XPages, external data, and Social Edition capabilities. The most important decision is whether you are preparing for a currently available assessment or studying a historical IBM credential: IBM states that the Advanced Application Developer - Notes and Domino 9.0 certification was withdrawn on November 30, 2019. Use this guide to map the subject matter to your experience, choose a practical lab sequence, and verify any available replacement or archival assessment before scheduling.
What the exam validates
The core requirement is more than familiarity with Domino Designer screens. IBM describes the application-development certification as requiring a deep understanding of Notes and Domino architectural concepts, complex functions and features, and technologies such as XPages, CSS, XML, and JavaScript. Your preparation should therefore connect design choices to runtime behavior, security, maintenance, and performance.
The official application-developer credential is identified as IBM Certified Application Developer - Notes and Domino 9.0 and is intended for developers using Domino Designer 9.0. IBM’s listed focus areas include application architecture, application debugging, application design elements, and application performance. Additional focus areas include the Extension Library, IBM Domino Designer and Eclipse, external-data integration, programming, security features, user management, and XPages.
The Social Edition context matters because IBM describes Notes and Domino 9.0 Social Edition as integrating social and business information to support expertise engagement, information sharing, and decision-making. That context should influence how you evaluate application boundaries and user interaction, but it does not replace the underlying application-development fundamentals.
Which credential and exam path are you actually targeting?
Confirm the credential name and current availability before investing in a booking plan. The official IBM page for the advanced path says that the Advanced Application Developer - Notes and Domino 9.0 certification was withdrawn on November 30, 2019; the supplied evidence does not establish a current delivery route for an exam called Application Development Update.
The available IBM material describes both an application-developer path and an advanced application-developer path. The standard page emphasizes architecture, design elements, debugging, performance, programming, XPages, security, user management, external data, and the Extension Library. The advanced page adds deeper architectural and feature knowledge, mobile development, workflow routing, advanced formulas, and broader data-access work.
Treat the title used by a catalogue or preparation site as a research label until IBM confirms the assessment. Do not assume that an old exam number, a retired certification, or a historical product release implies that registration is still possible. Check the official IBM certification page first, then use the syllabus topics as a skills-development plan if no active booking option exists.
Who should use this preparation plan
This guide is best suited to developers who already understand the purpose of Notes and Domino applications and need to organize advanced development practice around Designer 9.0, XPages, security, integration, and troubleshooting. It is less suitable as a first introduction to programming or to basic Notes client usage.
A developer building or modifying single-database and multi-database applications will recognize the practical setting described by IBM’s advanced certification guidance. The same guidance recommends experience building web-enabled IBM Domino 9.0 applications, accessing Domino and non-Domino data sources, routing workflow documents, and implementing security requirements.
Administration experience is useful because application behavior depends on server, directory, policy, access-control, and deployment decisions. IBM states that candidates with demonstrated Notes and Domino 9.0 system-administration proficiency through core administration tests or system-administration certification qualify for the Advanced Application Developer certification. That is an eligibility statement for the historical advanced path, not a reason to skip development practice.
How to turn the blueprint into study priorities
The supplied official evidence does not include domain percentages, question counts, scoring rules, test duration, languages, or delivery details. Do not create a percentage-based timetable from assumptions. Instead, prioritize topics by the number of design decisions they connect: architecture and data design first, then implementation, security, integration, debugging, performance, and platform-specific extensions.
Start with architecture because it frames every later decision. Review how a solution is divided across databases, forms, views, agents, shared resources, XPages, external services, and user-management controls. Then build a small application that lets you inspect the consequences of those choices rather than studying each feature in isolation.
Next, connect the architecture to implementation. A useful sequence is design elements and formulas, programming, XPages and client-side technologies, data access, security, debugging, and performance. Finish with Social Edition and mobile-related scenarios after the core application is stable. This order reduces the risk of memorizing interface locations without understanding how components interact.
What architecture knowledge should you demonstrate?
You should be able to explain why an application uses particular databases, design elements, data relationships, and execution locations. Architecture preparation is successful when you can predict the effects of a design on access control, maintainability, web behavior, data retrieval, workflow, and performance.
Use a deliberately small multi-database exercise. Put shared configuration or reference data in one database, transactional documents in another, and expose a controlled interface between them. Record which components are reusable, which require access to the current database, and which assumptions would fail when the application is opened through a web interface.
Review single-database and multi-database application construction because IBM lists both in the recommended advanced skills. Ask practical questions: Where is the authoritative data? Which users need access to each database? What happens when a document is moved or copied? Which lookup or routing operation becomes expensive as the data set grows?
Do not treat architecture as a diagram-only topic. For every design choice, write a short explanation covering ownership, security, deployment, failure handling, and future change. That explanation becomes a useful revision tool and exposes gaps more effectively than rereading feature names.
How should you practice design elements and formulas?
Build and modify forms, views, fields, agents, shared resources, and other design elements in a working application. Then use formulas to express validation, selection, display, routing, and data-manipulation behavior. The goal is to understand where logic belongs and how the chosen design element affects users and maintainers.
Create a workflow document with states such as draft, review, approval, and completion. Use form and view behavior to make state visible, validate required information, and support targeted work queues. Add an exception path so you must reason about rejected or returned documents rather than practicing only the successful route.
IBM specifically identifies advanced formula techniques and workflow document routing among the recommended skills for the advanced developer path. Practice formulas in context: selection formulas should produce the intended working set, validation should provide actionable feedback, and routing logic should handle missing, invalid, or unexpected values.
Keep a decision log beside the application. For each formula or agent, note its trigger, data assumptions, execution context, permissions, and expected result. When a test fails, you can determine whether the defect is in the formula, the design element, the document state, or the security model.
How do XPages, CSS, XML, and JavaScript fit together?
Treat XPages as an application layer that combines server-side data and behavior with browser-facing presentation and interaction. IBM lists XPages, CSS, XML, and JavaScript among the complex technologies relevant to the application-development certification, so study their boundaries and interactions rather than memorizing isolated syntax.
Build a small XPages interface over an existing Domino data model. First make data display and editing work with standard controls. Then add validation, navigation, conditional display, reusable resources, and a controlled client-side interaction. At each step, identify whether the behavior is handled by the server, the browser, a data source, or a design element.
Use CSS to separate presentation from application logic. Use XML where the platform or component configuration requires it, and use JavaScript only when the behavior belongs in client-side interaction or a supported server-side scripting context. Your notes should identify what data is exposed to the browser and what must remain protected on the server.
A common mistake is to copy an XPages example without tracing its data source, scope, security context, and lifecycle. Rebuild the example from a blank application, change the field names, introduce an invalid input, and test both authorized and unauthorized users. That turns recognition into transferable understanding.
What should you know about the Extension Library and Designer tools?
Study the Extension Library as a set of additional capabilities that must be selected, configured, and used deliberately. Also review the relationship between IBM Domino Designer and Eclipse, because IBM lists both the Extension Library and IBM Domino Designer and Eclipse among the focus areas for the application-development certification.
For each component you use, document its dependency, configuration location, supported data interaction, rendering behavior, and fallback plan. If a control improves navigation or presentation, verify how it behaves with validation, partial updates, access restrictions, and different application states.
Use Designer as a development environment, not merely a place to edit isolated elements. Practice locating source elements, tracing references, reviewing properties, checking generated or configured resources, and comparing a working version with a deliberately broken version. The exercise should end with a reproducible repair, not just a successful click sequence.
Avoid studying library names as if they were interchangeable. When a feature is unfamiliar, ask what problem it solves, what it depends on, and whether introducing it increases deployment or maintenance risk. Those questions support both exam reasoning and sound application design.
How should you prepare for external data integration?
Separate Domino data access from non-Domino data access in your practice plan. IBM lists integrating external data as a certification focus and recommends accessing Domino and non-Domino data sources for the advanced path. The key preparation task is to understand data shape, connection context, permissions, errors, and update responsibility.
Create one exercise that reads related information from a Domino source and another that consumes a non-Domino source or representative service available in your lab. Define what happens when the source is unavailable, returns incomplete data, changes its schema, or rejects the user’s credentials.
For every integration, record whether the application reads, writes, synchronizes, or merely displays external information. Identify where transformations occur and how you prevent external failures from producing misleading application state. Review caching and repeated retrieval behavior as performance and reliability concerns, without assuming that a particular implementation is universally correct.
Do not confuse a successful local connection with a secure production design. Test access under different identities, remove unnecessary privileges, and verify that sensitive values are not exposed through browser output, logs, configuration, or error messages.
How do security and user management change the design?
Security is an application behavior, not a final checklist. IBM includes security features and user management among the focus areas and recommends implementing security requirements for the advanced path. Prepare by showing how identity, roles, access controls, document-level restrictions, validation, and server-side enforcement work together.
Write a security matrix for your practice application. List user groups or roles, the databases and design elements they can use, the documents they may view or edit, and the operations they may perform. Then test the application using accounts with different permissions and attempt access through every available interface.
Distinguish presentation controls from authorization. Hiding a button or field can improve usability, but it is not a substitute for enforcing permission where the operation executes. Check direct document access, web requests, agents, shared resources, data sources, and administrative functions as appropriate to the design.
Include user-management cases in your revision notes: a user added to a role, a user removed from a group, an inactive identity, an unexpected name format, and a user who can reach the application but not a particular document. The exact platform configuration should be verified in the relevant IBM documentation and your lab, rather than inferred from a sample.
What Social Edition capabilities deserve focused review?
Social Edition preparation should concentrate on how applications expose and consume contextual information, gadgets, widgets, and embedded experiences. IBM’s iNotes 9.0 Social Edition documentation states that the Open Social component supports Widgets and LiveText, OpenSocial 2.0 gadgets, and embedded experiences.
Review the deployment model described by IBM: the Domino Social Edition Open Social component is deployed on a Domino mail server and another Domino server running Shindig. Use that model to reason about server roles, configuration dependencies, and the difference between an application feature and the infrastructure that enables it.
IBM also documents that widget automatic updates for iNotes users can be controlled through policies. Add a policy-focused exercise to your lab: identify what is being controlled, which users are affected, and how a policy decision changes the maintenance or rollout process. Do not assume a widget update is merely a client-side convenience.
Keep Social Edition scenarios tied to application outcomes. Ask whether the feature helps a user discover expertise, share information, act on a business document, or make a decision. That keeps the study grounded in IBM’s stated Social Edition purpose instead of treating social components as disconnected product vocabulary.
How should mobile development be studied?
For the advanced application-development path, IBM defines a mobile application as one built with XPages mobile controls. The listed mobile areas include design fundamentals and data handling, mobile core controls, local device interaction, responsive web design, mobile navigation, and Dojo Mobile.
Build a mobile-oriented XPages prototype that uses the same underlying business data as a desktop or web view. Start with a task-focused screen, then address navigation, validation, data loading, and display on a narrow viewport. Keep the workflow short enough that you can inspect every control and transition.
Review local-device interaction separately from server data handling. A device-oriented feature may have different availability, security, or failure behavior than a server-backed operation. Document what happens offline or when the connection is interrupted only if your supported platform and lab configuration provide that behavior; do not assume it from a generic mobile pattern.
Responsive design is not simply shrinking a desktop page. Evaluate control placement, readable content, navigation depth, input effort, and error recovery. Compare a mobile control-based design with a responsive web design approach and note which requirement each approach satisfies.
How do you prepare for debugging questions?
Debugging preparation should follow the path from user action to data result. IBM explicitly lists application debugging as a focus area, so practice isolating whether a defect comes from a design element, formula, script, data source, access rule, configuration, or rendering layer.
Create faults intentionally: an incorrect view selection, a missing field, invalid input, a failed data lookup, an unauthorized operation, and a client-side error. For each fault, capture the symptom, the narrowest reproducible case, the evidence you would inspect, and the confirmed fix.
Separate compilation or syntax problems from runtime and data problems. A valid script can still run in the wrong context; a valid formula can still select the wrong documents; a working page can still expose data incorrectly. Trace values and execution context instead of changing several components at once.
After repairing a defect, add a regression test. Verify the normal path, an invalid input, a boundary condition, and a user with different permissions. This approach is more useful than memorizing troubleshooting slogans and helps you reason through unfamiliar scenarios.
What performance decisions should your lab include?
Performance preparation means identifying where work occurs, how much data is processed, how often it is repeated, and which users or servers bear the cost. IBM lists application performance as a focus area, so connect performance observations to architecture, formulas, views, data access, XPages behavior, and integration design.
Use a repeatable test dataset in your lab and compare a baseline with one deliberate change. Observe response behavior, data retrieval, rendering, and repeated operations. Keep the comparison controlled so you can explain what changed rather than attributing an improvement to an unrelated edit.
Review expensive patterns such as unnecessary document processing, broad lookups, repeated external calls, excessive page data, and avoidable client-server interaction. The correct remedy depends on the application and platform configuration; the transferable skill is locating the cost and choosing a change that preserves correctness and security.
Do not optimize by removing validation, access checks, or useful user feedback. A fast application that returns the wrong documents or bypasses authorization is defective. Include security and correctness checks in every performance experiment.
Which study materials and notes are worth keeping?
Use the IBM certification pages to establish the scope and the IBM product documentation to verify Social Edition behavior. Because the supplied material does not provide a current exam blueprint or delivery specification for the catalogue title, maintain a personal topic map rather than relying on an unofficial list of supposed questions.
Create one page for each area: architecture, design elements, formulas and programming, XPages, Extension Library and Designer/Eclipse, external data, security and user management, debugging, performance, Social Edition, and mobile development. On each page, record a definition, a working example, a failure case, and the evidence you used to verify the behavior.
Keep source distinctions clear. A statement about a historical credential, a statement about a product feature, and a recommendation for lab practice are different kinds of information. Label them accordingly in your notes so that an old certification requirement is not mistaken for a current registration rule.
Avoid exam dumps, leaked questions, and memorization promises. They cannot establish whether an item is current or whether you can apply the underlying design principle. Use scenario prompts you create from the documented domains and verify the implementation in a controlled environment.
A practical study roadmap
A staged roadmap is more reliable than attempting every feature at once. Build one application through several passes: architecture and data model, design elements and workflow, XPages and presentation, integration, security, debugging, performance, and finally Social Edition or mobile extensions relevant to your target.
In the foundation pass, create the application structure, data model, forms, views, roles, and basic workflow. Write down the assumptions behind each choice. Confirm that you can explain the difference between a single-database design and a multi-database design and identify where shared or external data belongs.
In the implementation pass, add formulas, programming, XPages controls, CSS, XML configuration where required, and JavaScript behavior. Rebuild at least one feature without following a finished example. Test normal and invalid input and note which layer handles each result.
In the integration and protection pass, connect the application to the data sources available in your lab, define failure behavior, and enforce the security matrix. Test the same operation through each interface your application exposes. Then review user-management changes and verify that access decisions remain correct.
In the verification pass, introduce defects and measure the effect of controlled changes. Review application architecture, debugging evidence, and performance observations. If the advanced path is relevant, add XPages mobile controls and examine navigation, responsive behavior, mobile data handling, and local-device interaction within the limits of your supported environment.
Finish by producing a compact decision sheet. It should contain the purpose of each major component, its execution context, its security boundary, its data dependencies, its common failure modes, and the IBM source or lab observation that supports your note.
Common preparation mistakes to avoid
The most damaging mistakes are treating the title as proof of current availability, studying feature names without building anything, and confusing visible interface behavior with server-enforced security. Correct these early by verifying the credential, using a working lab, and testing with different identities.
Do not spend all your time on XPages while neglecting architecture, design elements, debugging, performance, security, and external data. IBM’s official scope is broader than any single technology. A polished page does not demonstrate that you can design a maintainable multi-database workflow or diagnose an access failure.
Do not assume that Social Edition features can be evaluated independently of deployment. IBM documents a server arrangement involving a Domino mail server and another Domino server running Shindig for the Open Social component. Record infrastructure dependencies and policy effects in your notes.
Do not convert uncertainty into invented exam facts. The supplied evidence does not establish current pricing, delivery method, duration, question count, passing score, language options, or scheduling windows. Treat those as items to confirm directly with IBM if an active assessment is identified.
Finally, do not use memorization as a substitute for implementation. When a practice question asks which design is appropriate, the strongest preparation is being able to explain the data flow, execution context, access decision, error behavior, and maintenance consequence.
What to do before attempting registration or final review
First verify whether IBM currently offers the assessment associated with your target title. The official advanced certification page records withdrawal on November 30, 2019, while the supplied sources do not provide a current replacement or delivery specification for an Application Development Update exam.
Next, compare your experience with the documented scope. Mark each area as demonstrated in a lab, understood conceptually, or not yet practiced. Give priority to gaps that cross several domains, such as a security issue in an XPages application that retrieves external data or a workflow design that affects performance.
Then run a final project review without notes. Explain the architecture, modify a design element, trace a failed request, test an authorization boundary, inspect an external-data failure, and justify a performance change. Add mobile or Social Edition work when it matches the advanced path or the role you are targeting.
Only after those checks should you decide whether to pursue a currently available IBM assessment, study for an employer-specific evaluation, or use the material as a historical Notes and Domino development plan. The official IBM pages remain the authority for credential status and any registration information.
Conclusion
The useful preparation target is demonstrable application-development judgment: selecting an architecture, implementing design elements and workflow, using XPages and related technologies, integrating data, enforcing security, debugging failures, and improving performance. Social Edition and mobile topics add platform-specific decisions, but they should be studied on top of those fundamentals. Because IBM records the advanced certification as withdrawn on November 30, 2019 and the supplied evidence does not confirm a current exam delivery path, verify status before scheduling. If no active assessment is available, the same roadmap still provides a disciplined way to maintain or evaluate Notes and Domino 9.0 development capability.
