Why Study with PlanetCert?
The Latest Questions
Practice questions and exam topics aligned with the current exam objectives.
Detailed Explanations
Go beyond the answer. Master the material with comprehensive learning and professional explanations for every concept.

AI-Powered Insights
Personalized preparation guidance that adapts to your performance and identifies weak spots automatically.
Exam Information
Official specifications published by IBM
Exam Format
Registration
Validity
Skills this practice test covers
- Tell the SPM Platform apart from the Application Modules, and pick the right ADE build target.
- Model Domain Definition, Entity, Struct, Process and Façade classes and their associations.
- Build UIM pages that create, read, update, delete and list one type of record.
- Add page logic with scriptlets, JavaScript and the CONDITION element.
- Customize code tables, message files and modeled classes in the compliant way.
- Implement deferred processes, batch jobs and REST APIs on the server.
Explore related topics
C1000-004 exam content
5 domains · 23 topics · 200 of 208 questions sorted by domain
IBM Cúram SPM Technical Infrastructure21%43 questions
This domain covers the ground under every Cúram project: the SPM Platform, the Application Modules, the runtime architecture and the Application Development Environment (ADE). It also asks how to localize, trace and debug the application, and how to judge the impact of a change or an upgrade.
Skills tested
- Tell the SPM Platform apart from the Application Modules that run on it.
- Find the project folders, file types and tools in the ADE, and pick the build target for a task.
- Use tracing to find the cause of a fault in the running application.
- Run an impact analysis before a customization or a version upgrade.
- Identify the features that localize the application for another language.
Questions by topic
- Identify the project folders, file types, and tools in the IBM Cúram SPM Application Development Environment (ADE)9
- Identify the relevant features for localizing applications5
- Perform tracing and troubleshooting8
- Differentiate between the components of IBM Cúram Social Program Management (SPM)6
- Perform impact analysis to determine the changes required for customizations and IBM Cúram SPM version upgrades7
- Select the appropriate build target for a particular task8
Server-Side Development30%56 questions
The largest domain is model-driven development on the server. Candidates model classes and associations, add stereotype operations, and write code that uses what the generator produces.
Skills tested
- Model Domain Definition, Entity, Struct, Process and Façade classes.
- Model Index, Foreign Key, Assignable and Aggregation associations.
- Define stereotype operations for Entity, Process and Façade classes.
- Define code tables, data manager files and message files.
- Add exception handling and validation, and import or export configuration data.
Questions by topic
- Model the following associations: Index, Foreign Key, Assignable, and Aggregation9
- Model the following classes: Domain Definition, Entity, Struct, Process, and Façade18
- Define appropriate stereotype operations for Entity, Process, and Facade classes13
- Use generated artifacts in application code8
- Implement exception handling and validation7
- Customize modeled classes compliantly1
Client-Side Development20%40 questions
This domain is about Cúram pages, which are written in UIM. Candidates build pages that create, read, update, delete and list (CRUDL) records, set up navigation, and add logic to pages.
Skills tested
- Build pages with UIM elements such as PAGE, CLUSTER, FIELD, LINK and SERVER_INTERFACE.
- Implement a CRUDL set of pages for one type of record.
- Add wizards, select lists, editable lists, expandable lists and in-page navigation.
- Add page logic with scriptlets, JavaScript and the CONDITION element.
Questions by topic
- Add logic to UIM pages using scriptlets, JavaScript, and the CONDITION element9
- Implement the following client features: multiple submit, select lists, views, wizards, in-page navigation, help, editable lists, expandable lists, and containers10
- Implement UIM pages for CRUDL (create, read, update, delete, and list) applications7
- Use common UIM elements: PAGE, CLUSTER, FIELD, CONNECT, LINK, PAGE_PARAMETER, SOURCE, TARGET, SERVER_INTERFACE, ACTION_SET, ACTION_CONTROL14
Server-Side Customization21%39 questions
This domain asks how to change the shipped server code compliantly, so that later IBM upgrades still apply. It also covers web services and REST APIs for real-time integration, and background work such as deferred processes and batch jobs.
Skills tested
- Customize message files, code tables, data manager files and server configuration files compliantly.
- Customize modeled and non-modeled classes without editing the shipped code.
- Implement web services and REST APIs for real-time integration.
- Implement custom events, deferred processes and batch jobs.
Questions by topic
- Implement custom events, deferred processes, and batch jobs13
- Customize modeled classes compliantly6
- Customize the following artifacts compliantly: message files, code tables, data manager files, server configuration files, and configurable validations8
- Customize non-modeled classes compliantly6
- Implement web services and REST APIs for real-time integration6
Client-Side Customization8%22 questions
The smallest domain covers changes to the shipped user interface. Candidates customize pages, navigation and property files compliantly, and compare the options for customizing widgets.
Skills tested
- Customize a shipped page and its navigation without editing the original files.
- Change page labels and other text through property files.
- Choose among the options for customizing a widget.
Questions by topic
- List and describe the options for customizing widgets8
- Customize pages, navigation, and property files compliantly14
Requirements
- No formal prerequisites: anyone can book the exam.
- Recommended: hands-on work in the IBM Cúram SPM ADE and experience with Java development.
- Recommended: familiarity with model-driven development and with social program management concepts.
About the C1000-004 exam
C1000-004 tests whether a developer can build and customize applications on IBM Cúram Social Program Management (SPM). Cúram SPM is IBM's software for public agencies that run social programs. The exam covers the model-driven server side, where classes in a model generate much of the code, and the client side, where pages are written in XML files called UIM. A large share asks how to change the shipped application without breaking later upgrades. Passing earns IBM Certified Application Developer - Cúram SPM V7.X.
Server-Side Development is the largest domain, and the PlanetCert practice test gives it the most questions, from Domain Definitions to stereotype operations. Each explanation says why one class type, association or UIM element fits the case and why the others do not. Flashcard mode suits the many UIM element names, such as PAGE_PARAMETER and ACTION_SET. Brainy AI Assistant can explain when a change counts as compliant, or how a deferred process differs from a batch job.
How to earn the certification
- Earns
- IBM Certified Application Developer - Cúram SPM V7.XProfessional
IBM sets no expiry date for this certification.
How to prepare for C1000-004
- 1
Learn the parts of Cúram SPM
Sort the product into the SPM Platform and the Application Modules, and trace a request through the runtime architecture. Then open the ADE and find its project folders, file types and build targets.
- 2
Model one entity from end to end
Model a Domain Definition, an Entity, a Struct and a Façade, add stereotype operations, and run the build. Server-Side Development is the largest domain, so repeat this until each class type feels familiar.
- 3
Write a CRUDL set of pages
Build UIM pages that create, read, update, delete and list one record type, with PAGE, CLUSTER, FIELD, LINK and SERVER_INTERFACE. Add a CONDITION element and a wizard for the advanced client features.
- 4
Customize without touching shipped files
Change a code table, a message file and a modeled class the compliant way, then a page, its navigation and its property file. Note which mechanism each change uses, because both customization domains ask about it.
- 5
Drill UIM names in Flashcard mode
Use Flashcard mode for the UIM elements and the association types, then work through the C1000-004 practice test in Study Mode. Finish with a Timed Mode run, and ask Brainy AI Assistant about each missed customization case.
Start a timed C1000-004run
Who C1000-004 is for
- Developers on Cúram projects who write the model, the server code and the pages.
- Consultants on social program projects who customize the shipped Cúram application.
- Java developers who are moving onto a public sector project that runs Cúram.
Typical job titles: Cúram developer · Java developer · Application developer · Technical consultant · Software engineer
C1000-004 glossary
18 terms from the exam objectives and the vendor's official material, each defined in a sentence.
- Application Development Environment (ADE)
- The Cúram project folders, generators and build tools that developers use to build and customize the application.
- Application Modules
- The ready-made Cúram solutions for particular kinds of programs, which run on the SPM Platform.
- Build target
- A named step in the ADE build, such as building the server or the client, picked to match the change made.
- Code tables
- Lists of allowed values that the application stores as short codes and shows as readable descriptions.
- Compliant customization
- Changing Cúram the way IBM's customization rules allow, without editing shipped files, so upgrades stay possible.
- CONDITION element
- A UIM element that shows or hides part of a page depending on a value from the server.
- Data manager files
- Files that hold the rows to load into database tables when the database is built.
- Deferred processes
- Server work that is put in a queue and run later, outside the transaction of the user who started it.
- Domain Definition
- A modeled data type that sets the base type and rules for attributes, so that many fields share one definition.
- Entity
- A modeled class that maps to a database table and has stereotyped operations, such as insert and read.
- Façade
- A modeled class whose operations the client pages call, so it forms the server's interface to the user interface.
- IBM Cúram Social Program Management (SPM)
- IBM's software for agencies that run social programs, built as a platform with application modules on top.
- Message files
- Files that hold the text of messages, such as validation errors, so the text can change without code changes.
- SERVER_INTERFACE
- The UIM element that names the server operation a page calls to read or save its data.
- SPM Platform
- The base layer of Cúram SPM, with the shared services and tools that every application module runs on.
- Stereotype
- A label on a modeled class or operation that tells the code generator what kind of code to create.
- Struct
- A modeled class that groups attributes to carry data between operations, with no database table of its own.
- UIM
- The XML format in which Cúram pages are written, with elements such as PAGE, CLUSTER and FIELD.
Related practice tests
- C2090-616DB2 11.1 Fundamentals for LUW
- S2000-025IBM AIX v7.3 Administrator Specialty
- C1000-171IBM App Connect Enterprise V12.0 Developer
- C1000-150IBM Cloud Pak for Business Automation V21.0.3 Administration
- C1000-147IBM Cloud Pak for Integration V2021.4 Solution Architect