Build a Readable Rules Language for Insurance Policies in OCaml
Overview
What this challenge is about.
Build a Readable Rules Language for Insurance Policies in OCaml. Intermediate challenge in code. Writing production code that solves real engineering problem...
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.
This is not a coding exercise. It is the work a software engineer does between a Jira ticket and a merged PR. That distinction matters to every hiring manager who has seen candidates solve LeetCode problems and none who have shipped production code under real constraints.
When you finish, you will have something most graduates do not: a real-world deliverable, verified by Ewance, that you can show to a hiring manager and say "I did this. Here is the proof."
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