Build a Readable Rules Language for Insurance Policies in OCaml
Overview
What this challenge is about.
Design an insurance policy rules language in OCaml, parse and test six rules against a catastrophe-zone table, and earn a verifiable certificate.
The scenario
The company is a specialty insurance managing general agent in Zurich (about 95 staff) underwriting commercial cyber and parametric weather cover, where actuaries — not engineers — own the pricing and coverage rules but cannot touch the Java that encodes them.
The Brief
What you'll do, and what you'll demonstrate.
Design and implement a small OCaml domain-specific language for insurance policy rules that actuaries can read and author themselves, proven by six real rules ported from the existing system.
Earning criteria — what you'll demonstrate
- Design a small, learnable domain-specific language scoped to a real non-engineer audience.
- Model an abstract syntax tree with OCaml algebraic data types and evaluate it with exhaustive pattern matching.
- Build a parser (combinators or a generator such as Menhir) that turns concrete syntax into the AST.
- Translate imperative legacy logic into declarative, readable rules without changing behavior.
- Gather and present usability evidence that a design goal (actuarial readability) was actually met.
Program Fit
Where this fits in your program.
Sharpens the same skills your degree expects you to demonstrate.
Aligned coursework coming soon.
Skills
Skills you'll demonstrate.
Each one shows up on your verified credential.
- Ocaml
Apply ocaml to solve real industry problems and demonstrate production-level capability.
- Domain Specific Languages
Apply domain specific languages to solve real industry problems and demonstrate production-level capability.
- Parser Combinators
Apply parser combinators to solve real industry problems and demonstrate production-level capability.
- Ast Design
Apply ast design to solve real industry problems and demonstrate production-level capability.
- Pattern Matching
Apply pattern matching to solve real industry problems and demonstrate production-level capability.
- Type Driven Design
Apply type driven design to solve real industry problems and demonstrate production-level capability.
Careers
Career paths this challenge builds toward
Completing this challenge demonstrates skills that transfer directly to these roles:
Language / Compiler Engineer
Designing a small language end-to-end — surface syntax, AST, parser, and interpreter — is the core of compiler and language tooling work. This challenge gives you a portfolio artifact showing you can scope a language to a real audience and implement it cleanly in a functional language.
This challenge sharpens
- domain-specific-languages
- ast-design
- parser-combinators
Functional Programming Engineer
Teams using OCaml, Haskell, or Scala prize type-driven design and exhaustive pattern matching. By modeling rules as algebraic data types and evaluating them with pattern matching, you demonstrate exactly the habits these teams hire for, on a non-trivial real-world problem.
This challenge sharpens
- ocaml
- pattern-matching
- type-driven-design
Platform / Internal Tools Engineer
Building a language that lets non-engineers author logic safely is a classic internal-platform problem. This challenge shows you can replace brittle code-owned business logic with a tool domain experts operate themselves, balancing expressiveness against learnability.
This challenge sharpens
- domain-specific-languages
- type-driven-design
- ast-design