Insurance Policy Management & Document Generation Platform
A web platform that replaced Ghana-based Aban's Insurance Brokerage's spreadsheet-driven workflow with a structured three-step digital process — covering 21 insurance types, dynamic per-type fields, automated PDF generation at every stage, and direct client email delivery from within the system.
Client
Aban's Insurance Brokerage
Product
Insurance Policy Management Platform
Service
Product Engineering
Engagement
End-to-End Build
Client Overview
Aban's Insurance Brokerage is a Ghana-based professional insurance brokerage managing policies across 21 insurance types for their client base. Their team handles the full policy lifecycle — from initial quotes through to placement slips and invoicing — for each individual client they serve.
Every insurance policy was managed through Excel spreadsheets. Each insurance type had its own template with type-specific fields. Staff would fill in the relevant template, print it, and manually email the completed document to the client. With 21 different insurance types each following their own field structure, the process was slow, error-prone, and entirely dependent on manual effort at every step.
Replace the spreadsheet workflow with a purpose-built web platform — one that models each insurance type's fields at the database level, guides staff through a structured three-step process per policy, automatically generates properly formatted PDFs at each stage, and sends documents directly to clients without any manual email handling.
Problem & Challenges
Business Problems
- Managing 21 insurance types via separate Excel templates was slow, inconsistent, and impossible to scale as the client base grew
- Staff had no structured workflow — documents were produced ad hoc with no stage tracking or process enforcement
- Manual email delivery of documents introduced delays and required staff to context-switch between the spreadsheet and their email client
- No client records system meant policy history was scattered across files with no central view per client
- Dynamic options like covers, deductibles, and extensions were not standardised — each staff member managed them differently
Technical Challenges
- Modelling 21 insurance types at the database level so each type stores only its own relevant fields — with the UI dynamically rendering only the fields applicable to the selected type
- Building a three-step policy workflow (Inception to Quote → Placement Slip → Invoice) where each stage inherits relevant data from the previous step while adding its own stage-specific fields
- Generating properly formatted, print-ready PDFs using @react-pdf/renderer for each of the three stages — with layout and content adapted per insurance type
- Implementing a quick document generation mode that bypasses the full workflow, letting staff select a type and stage independently and generate a standalone document on demand
- Building a dynamic options management system for Covers, Deductibles, and Extensions — where each option set is type-specific and admin-configurable without code changes
Objectives & Success Criteria
Our Objectives
Success Criteria
Client Enrolment
Allow staff to enrol clients into the system and initiate a new insurance policy tied to a specific insurance type.
Success Criteria
Zero Spreadsheets
All policy data entry, document generation, and client communication handled entirely within the platform.
Three-Step Policy Workflow
Build a sequential workflow — Inception to Quote → Placement Slip → Invoice — where each stage loads the correct type-specific fields and advances only when the current stage is complete.
All 21 Types Covered
Every insurance type modelled in the system with its own field set, dynamic options, and PDF layout.
Dynamic Field Rendering per Type
Store each of the 21 insurance types' fields separately at the database level, rendering only the relevant fields when a type is selected.
Automated Document Delivery
Generated PDFs sent directly to clients via Resend from within the system — no manual email step.
Automated PDF Generation
Generate a properly formatted, print-ready PDF at each stage of the workflow — formatted correctly for the selected insurance type.
Flexible One-Off Documents
Staff can generate any stage document for any type on demand without following the full three-step process.
Direct Client Email Delivery
Allow staff to send generated PDFs directly to the client's email address from within the system using Resend — no manual email required.
Dynamic Options Management
Build an admin-configurable system for Covers, Deductibles, and Extensions per insurance type — staff can add and update these options at any time.
Quick Document Generation
Provide a standalone mode where staff can select any insurance type and any stage, fill the relevant fields, and generate a document immediately — without initiating a full workflow.
Our Solution
We built Aban's Insurance Brokerage's platform on Next.js and MongoDB, with each of the 21 insurance types stored as its own field schema in the database. When a staff member selects an insurance type, the system renders only the fields relevant to that type — eliminating the confusion of managing 21 separate spreadsheet templates. Each policy follows a three-step workflow: the staff member initiates an Inception to Quote, filling in the type-specific fields for the first stage. Once finalised, the policy advances to the Placement Slip stage, which carries forward the shared fields and presents the additional slip-specific inputs. The final step generates the Invoice, pulling from the data already captured in the previous stages. At every stage, the system generates a properly formatted PDF using @react-pdf/renderer, with each PDF laid out correctly for the selected insurance type. Staff can send the generated document directly to the client's email address via Resend without leaving the platform. For situations where a full three-step workflow is unnecessary — such as reissuing a single document or generating a standalone slip — a quick document generation mode lets staff select an insurance type and a specific stage, fill in the relevant fields, and produce a PDF immediately. The platform also includes an admin-managed dynamic options system for each insurance type, covering Covers, Deductibles, and Extensions — all configurable without code changes.
Client Enrolment & Policy Initiation
Staff enrol clients into the system and initiate a new policy by selecting the relevant insurance type, which loads all type-specific fields for the first stage.
Three-Step Policy Workflow
Sequential Inception to Quote → Placement Slip → Invoice workflow, with each stage loading the correct fields and inheriting data from the previous step before advancing.
Dynamic Field Rendering per Type
21 insurance types stored at the database level with their own field schemas — only the relevant fields render when a type is selected, across all three stages.
PDF Generation per Stage
Properly formatted, print-ready PDFs generated at each of the three stages using @react-pdf/renderer, with layouts adapted per insurance type.
Direct Email Delivery via Resend
Generated PDFs sent directly to the client's email address from within the system — staff never need to switch to a separate email client.
Dynamic Options Management
Admin-configurable Covers, Deductibles, and Extensions per insurance type — staff can add and update options for any type at any time without code changes.
Quick Document Generation
Standalone mode for generating any stage document for any insurance type on demand — select type, select stage, fill fields, generate PDF, send to client.
Implementation & Delivery
Scope of Work
The engagement covered the full platform from scratch — client management, the three-step workflow engine, dynamic field rendering, PDF generation, email delivery, and the quick document mode. Built on Next.js with MongoDB and Mongoose, authenticated via NextAuth.js, with @react-pdf/renderer handling all document generation and Resend managing email dispatch.
- Client enrolment and policy initiation flow
- Three-step policy workflow (Inception to Quote → Placement Slip → Invoice)
- Dynamic field rendering engine for 21 insurance types
- PDF generation at each stage (@react-pdf/renderer)
- Direct email delivery from system (Resend)
- Dynamic options management: Covers, Deductibles, Extensions per type
- Quick document generation mode (type + stage selection → PDF → email)
- NextAuth.js-authenticated staff portal
21 Types, One Interface
Every insurance type is modelled at the database level with its own field schema. Staff select a type and the correct fields appear instantly — no templates, no spreadsheets, no switching files.
Three-Step Workflow Enforcement
Policies progress through Inception to Quote, Placement Slip, and Invoice in sequence — each stage inherits the right data from the previous step, eliminating re-entry and inconsistency.
PDF + Email in One Action
Staff generate a properly formatted PDF and send it directly to the client's email from within the platform — the full document delivery workflow is a single action.
Quick Mode for One-Off Documents
When the full workflow is not needed, staff can pick any type and stage, fill the fields, and generate a document immediately — giving them flexibility without breaking the structured process.
Technology Stack
Next.js
React
TypeScript
Tailwind CSS
MongoDB
Mongoose
NextAuth.js
@react-pdf/renderer
ResendResults & Impact
Aban's Insurance Brokerage eliminated their spreadsheet-based workflow entirely. All 21 insurance types are managed within a single platform, each policy follows a structured three-step process, and documents are generated and delivered to clients automatically. Staff spend their time on brokerage work, not on formatting documents and sending manual emails.
21
Insurance Types
3 (Quote → Slip → Invoice)
Workflow Steps
Automated per Stage
PDF Generation
Fully Eliminated
Manual Email Tasks
Evolution & Long-Term Value
The platform is built to accommodate new insurance types, additional dynamic options, and new document layouts without architectural changes. As Aban's client base grows, new policy types can be added through the admin panel, and the quick document generation mode ensures the team always has a flexible fallback for non-standard requests.