Become a Certified Novulo Developer.
Update: Start date revised to 30 March 2026.
Bring innovation to the insurance industry with the Novulo Insurance Academy. In a unique, hands-on training program you will learn to build, implement, and manage your insurance solutions using the Novulo platform.
- Limited spots available
- English-language (subject to confirmation)
- Includes self-study assignments
- Zeist, Utrechtseweg 60
The Developer program is structured into two progressive levels. Weeks 1 - 3 are the Starter level and week 13 is the Advanced level.
Week 1
Day 1 workshops (30 mar): Mission, vision and technology, Way of working and Getting started
Day 2 workshops (31 mar): Setting up my organization and Product setup
Day 3 workshops (1 apr): Policy administration and renewal, Expressions and Export,
Day 4 workshops (2 apr): Output, and Deployment
Day 5: room for self practice, self-study assignments and project work
Week 2
Day 1 (6 apr): Easter monday
Day 2 workshops (7 apr): Claim submission and settlement, Financial processed and Compliance
Day 3 workshops (8 apr): Workflows and Datasets
Day 4 workshops (9 apr): Authorisation, Expressions and Import engine
Day 5 workshops (10 apr): REST endpoints and Chain communication.
Week 3
Day 1 workshops (13 apr): Architect, Expression debugger and Debugging analysis
Day 2 workshops (14 apr): Bug fixing
Day 3 workshops (15 apr): New feature development and Advanced Expressions
Day 4 workshops (16 apr): Automated testing and Performance optimalization
Day 5: room for self practice, self-study assignments and project work
Weeks 4–12
Practical project period with weekly online mentorship (20 Apr - 19 Jun).
Week 13
Day 1 workshops (22 jun): Design process and component development
Day 2 workshops (23 jun): Component development
Day 3 workshops (24 jun): Plugins and Store delivery
Day 4 workshops (25 jun): Performance optimalization
Day 5: room for self practice, self-study assignments and project work
Preparation
To get the most out of this program, a solid foundational understanding of the insurance domain is essential, including policy structures, coverages, claims, premium calculations, renewal processes, and more.
We also expect strong analytical thinking skills, enabling participants to understand complex processes and data models.
Get in touch
Not sure whether this program is the right fit for your background? Feel free to contact us at academy@novulo.com
Learning goals
In week 1 and 2 implemenation specialists and developers will learn to:
- Understand Novulos’ competitiveness, ecosystem, strengths, manifest and composability.
- Understand Novulos’ 10 step way of working approach in implementing an insurance solution.
- Analyse customer requirements with checklists to create backlog items for each of the 10 steps way of working.
- Access and navigate within the Novulo Application and community.
- Configure SIVI/AFD products and customs products using backlog items and a product book.
- Understand the insurance lifecycle (from product to output).
- Configure policy acceptance, mutations and prolongation.
- Configure and test acceptance criterium, mutation of an insurance and prolongation period.
- Add and test the VPI calculation box, acceptance criteria and restrictions to acceptance criteria.
- Carry out bulk mutations and mutation groups.
- Understand the usage of expressions and datamodel.
- Create and test basic expressions.
- Configure an activity template (polisblad) and e-mail.
- Use different types of dynamic output (i.e. documents and e-mails).
- Re-use content with content blocks.
- Apply corporate identities.=
- Understand the deployment street of composer, deployment, appserver and installer.
- Understand, setup and use (AT) of the phased approach (D(I)TAP).
- Understand component revision statuses (WIP, NB, CTP, Beta, Baseline and Stable).
- Change the composition of your application.
- Understand how to check for and deal with updates to compononents in your composition.
- Deploy changes to your application instances.
- Understand how to read, start and restart workflows.
- Configure a workflow and its parameters, steps and transitions.
- Understand why and how to use datasets and its relation to exportdefinition.
- Make your own dataset (embedded import export)
- Install or manually import a new or improved dataset.
- Understand the claim cycle from submission to payment.
- Configure a claim process in order to process, submit and adapt a claim through the back-office.
- Understand how cashflows work in an underwriting set-up.
- Configure a ledger administration
- Understand how authorisations work.
- Configure rights profiles.
- Understand why and where imports are used.
- Configure and create (embedded) import definitions.
- Configure endpoints
- Configure a new contract
- Create a new chain communication.
In week 3 developers will learn to:
- Install, access and navigate within the Novulo Architect.
- Understand producing and consuming and User Interface, Expressions, Processes and Data model
- Find the source of an error of function of a field by searching in the architect.
- Understand producing and consuming in components.
- Understand how to approach issues, errors and bugs.
- Distinguish between configuration and development errors.
- Debug issues using system health, workflow analysis, expression debugger, page performance analysis, datamodel, architect and trace analysis.
- Fix the architect errors based on problems tab.
- Understand what the reference architecture guidelines are en why this is used in Novulo.
- Understand how model rights work in gaining access to models or components.
- Create and deploy a small application for easy development work.
- Extend your application with a new component.
- Understand the difference between model (structure), GUI/data (output) and process (workflow)
- Understand how to develop a new feature (code change) including configuration, database and dataset.
- Check the validity and configuration in the application using system health.
- Automate testing processes and streamline development workflows.
- Understand the levels of quality assurance from design, QA scanner to peer review.
- Combine auto testing, documentation and datasets.
In week 13 developers will learn to:
- Design and implement a new component, including its data model, business logic, and user interface, while ensuring alignment with the overall architecture.
- Apply product-oriented principles: building reusable, generic components instead of one-off project solutions, and thinking ahead about maintainability and extensions.
- Understand how to choose the right plugin structure, interaction with the framework while take in mind dependencies, re-use and functionality.
- Understand when a new generic fine-grained component is needed.
- Understand the pay-off between reading and writing as part of performance optimalisation
- Write an index to improve the performance of the application
- Cache a function (in the database) as part of performance optimalisation
- Understand the concept of cascading functions.
- Understand to make effective use of logging to analyse performance issues and application behaviour.
- Publish a component in the Novulo store.
- Prepare a new component with required plugins and dependencies, implement common plugins (e.g. REST communication with insurance test environments), and apply tips and tricks to make the component
- unctional and reusable.
- Validate that a component is “store-ready”
- Implement logging and system health checks that provide actionable insights, ensuring components remain transparent and supportable in production.
- Produce complete, usable documentation that explains the function, configuration, and implementation steps of the component so consultants can work independently.
- Participants can restore a backup to a prelive environment and decide whether to include updates or roll them back.
- Locate and interpret deployment logs, Installer queue, and Appserver queue to recognize where tasks are stuck and what the error states mean.
KOSTEN: €9,900.- per deelnemer (excl. BTW)
