Mendix Advanced Developer study plan

Model a generalization hierarchy with at least two specialized entities and justify in writing where inheritance is better than a one-to-one association.

Configure reference and reference-set associations, set delete behavior for each relation, and record the cascade consequences for five sample records.

Normalize a denormalized event-registration dataset into at least six entities and check the result against three user stories.

Replace stored duplicated values with calculated attributes or non-persistent entities, and verify the values on a page.

Define four module roles and write entity access rules with XPath constraints for create, read, update, and delete.

Configure page access and microflow access per module role, then verify allowed and denied paths with demo users.

Implement an owner-based XPath constraint so users see only records they created, and test it with two users.

Document the role-permission matrix and identify three rules that could leak data if left at default.

Implement five custom validation rules in microflows with specific error messages and member-level feedback.

Add error handling around a multi-step microflow using error events, rollback behavior, and structured logging for three failure paths.

Build a nanoflow validation path for an offline-capable form and confirm it behaves the same as the online microflow.

Write ten unit-test microflows using the Mendix Unit Testing module and run them as a suite.

Consume two REST endpoints using import mappings and handle success, 4xx, and timeout responses explicitly.

Publish one OData or REST service with authentication and test it with six request cases.

Map nested JSON arrays into related entities and verify parent-child records after import.

Add integration error handling that logs the request identifier, rolls back partial data, and returns a user-safe message.

Consume a SOAP service from a WSDL and map the response into the domain model with fault handling.

Design a JSON structure and export mapping for an outbound payload used by two different consumers.

Implement retry, timeout, and idempotency behavior around one integration and document the limits.

Publish a REST service with role-based authentication and validate three unauthorized access attempts.

Profile three list pages and reduce database queries by changing retrieve patterns and adding indexes where supported.

Refactor a duplicated microflow into reusable sub-microflows with a documented interface and error contract.

Design a reusable module with exposed entities, microflows, module roles, and a README describing its public API.

Import the reusable module into a second app and verify the exposed interface works without changes.

Configure a deployment with environment-specific constants and secrets, and document the promotion path from test to acceptance.

Implement one Java action that parses a JSON payload or calls a REST service, including exception handling and logging.

Set up structured logging, a health check, and a rollback procedure, then rehearse the rollback once.

Document backup/restore expectations and the scaling limits observed in the test environment.

Re-run every weak objective from weeks 1-7 and close each gap with a hands-on change, not a reread.

Complete a timed 60-question mock exam spanning all eight domains and review every wrong answer.

Rebuild one end-to-end slice covering domain, security, validation, integration, and deployment without notes.

Finalize a one-page architecture decision record for the sample app covering trade-offs and known limits.