Rapid-App - Insurance Platform

Portfolio, Ventures & What I Build

Product/systems design that turns AI tech into business results

I'm Gil, an AI Product Design Engineer. I take complex workflows and turn them into AI-native systems, from discovery through shipped product.

My north star is the complete practitioner: the idea that the best AI-native products are shaped by one mind that can hold design, engineering, and AI logic simultaneously, not handed off through layers of interpretation.

When the same person who defines the workflow also builds the prototype and wires the AI, translation loss disappears. Teams move faster and the gap between what we designed and what shipped closes.

What I Bring

Enterprise Systems

Enterprise End-to-End Systems Builder

I've designed complex product ecosystems at enterprise scale — multi-product platforms, multi-role workflows, and long-running transformation initiatives as a solo designer. Systems thinking, not just screen design.

AI Product Engineering

AI-Native Product Design Engineer

I design and prototype AI-native product systems — RAG pipelines, agentic workflows, human-in-the-loop interfaces, structured outputs, and context-aware products. AI product work grounded in real systems, not demos.

Education & Evangelism

Technical Educator & Evangelist

I help people understand, adopt, and build with new technologies — through demos, workshops, tutorials, and product systems thinking. Teaching as adoption; adoption as product design.

A consistent practice across technology cycles

Tech Speaker Microsoft · 5,000+ developers

Co-founder 8th Light · Digital transformation

Startups + Enterprise Engine Yard · ThoughtWorks · Dev tools

Founder Skowak · Design engineering · Teaching

Enterprise Focus SunPower · Digital transformation · Ecosystems

AI Eng Focus Craftal · CareDash · Multi Agent Systems

Now Contextus · Craftal v.2 · AI-native systems

How I Work

I don’t start with AI. I start with how work actually happens.

The method works in cycles. Each one scoped small enough to prove value fast, wide enough to compound across the whole system.

Each cycle makes the next one faster, safer, and more valuable. Real workflows before AI use cases. No baseline, no proof. No proof, no scale.

01 — 03

Understand

Discover
Model
Baseline

Know before you build

04 — 06

Intervene

Design
Adapt & Script
Measure

Build small, prove value

07 — 08

Promote

Promote
Orchestrate

Make it durable and connected

09 — 10

Scale

Govern
Reuse & Expand

Govern and compound

Where most AI projects break down

Most AI failures aren't technical. They're structural: siloed teams, AI built without real workflows, ideas that can't survive contact with production. The method closes those gaps.

Design, engineering, and AI in separate rooms

Work lands in three different hands. Every handoff is a translation, and translation is where ideas lose fidelity.

One practitioner across all three layers

I lead design, write code, and wire the AI as one strategic partner across all three disciplines. No handoffs, no interpretation layers, no gap between what was designed and what shipped.

AI built without a workflow to plug into

Teams rush to launch LLM features with minimal ROI. Without mapping real workflows or solving real problems, the result is unused chatbots and shallow automation.

Bridge between LLMs and real work

I map how work actually happens first, then wire the AI stack into those real decisions. The result is automation that runs, not a chatbot no one uses.

Technical Toolkit

The full stack, from workflow model to deployed AI system.

My stack spans the full system: AI engineering (OpenAI & Anthropic APIs, LangChain, LangGraph, DSPy, RAG pipelines, vector stores, structured outputs, agent orchestration), frontend and prototyping (React, Angular, Vue, TypeScript, API-connected interfaces), backend and tooling (Python, FastAPI, Rails, PostgreSQL/pgvector, Docker), and product and design (systems modeling, workflow mapping, information architecture, interaction design, design engineering).

As a product generalist, I choose the right tool for each layer (design, front end, data, or model) so ideas travel from workflow model to shipped system without unnecessary handoffs.

Getting personal

Things I do when I'm not building

Still-life sketching, coastal hiking, PC teardowns, and slow travel through cities with good architecture.

I draw to stay sharp. I travel to stay curious. I take things apart to stay honest about how they work.

Back

Rapid-App - Insurance Platform

A guided agent platform that made life insurance applications and underwriting faster, clearer, and easier to complete.

Skills applied:

Visual Design Interaction Design Frontend Dev Backend Dev Prototype Dev Research Information Arch

Life insurance applications were slow, error-prone, and difficult for agents to complete consistently. The process depended on long forms, eligibility rules, payment details, beneficiary data, and signature steps that could easily break down.

I helped design RapidApp as a guided application workflow for Fidelity Life agents. The product turned a complex insurance intake process into a structured digital path with clear steps, validation, status tracking, and e-signature readiness.

The Problem

A long application process with too many places to fail.

Applying for life insurance required agents to collect personal details, health information, coverage preferences, beneficiary data, payment information, and signature confirmation. Each step carried compliance risk and could delay the application if information was missing or inconsistent.

The real challenge was not simply digitizing a form. The product needed to guide agents through a regulated workflow while helping them avoid mistakes, understand application status, and move customers toward submission without unnecessary back-and-forth.

diagram rapidapp 01 — A fragmented insurance workflow created delays, rework, and incomplete applications.

Solution

A structured path for agents to complete applications with confidence.

I designed RapidApp around a simple idea: agents should always know where a case stands, what information is missing, and what step comes next. Instead of treating the application as one long form, the interface broke the process into clear sections with persistent navigation and completion states.

fidelitylife rapidapp 01 — The Active Cases view gave agents a clear queue of in-progress applications.

The experience started with a case management screen where agents could search, review, archive, or create new applications. This turned the application process into an operational workspace, not just a data-entry tool.

fidelitylife rapidapp 03 — Agents started by selecting the product and issue state.

From there, the flow captured the insurance product and state before opening the application. This mattered because insurance rules and available products depend on location, eligibility, and product configuration.

diagram rapidapp 02 — RapidApp turned scattered intake requirements into a guided, validated workflow.

The application itself used a left-side stepper to show progress across Basic Information, Contact Information, Prequalification Questions, Coverage Applied For, Other Coverage, Beneficiary Information, Owner Information, Additional Information, and Agent Declaration.

fidelitylife rapidapp 05 — The Basic Information step organized applicant identity and address details.

This structure gave agents a predictable path while keeping the application flexible enough for complex insurance scenarios.

fidelitylife rapidapp 08 — Prequalification questions helped surface eligibility issues early.

A key part of the design was moving critical eligibility questions earlier in the workflow. Instead of discovering problems at the end, agents could answer prequalification questions and understand whether the application could proceed.

fidelitylife rapidapp 09 — Coverage configuration connected plan, amount, term, and purpose.

The coverage step translated product selection into concrete application details. Agents could configure the plan, insurance amount, term period, and purpose of insurance in a clean, focused view.

fidelitylife rapidapp 15 — Beneficiary tables made split percentages and relationships easier to manage.

For beneficiary information, I used a table-based pattern with modal entry. This kept the main screen readable while supporting required details like relationship, SSN or tax ID, and split percentage.

Outcome

A faster, clearer path from intake to submission.

RapidApp helped agents move through a life insurance application with more structure and fewer unknowns. The product reduced ambiguity by showing progress, enforcing required information, and connecting e-signature status directly to the application workflow.

fidelitylife rapidapp 19 — The e-signature step showed when an application was ready for customer signature.

The e-signature flow was especially important. The interface made it clear when an application was incomplete, when signature details had been sent, when the customer had signed, and when the application was ready to submit.

fidelitylife rapidapp 25 — The completed state confirmed signed documents and underwriting submission.

The final experience gave agents a clear confirmation state with signed documents, submission date, confirmation number, and underwriting status. This created a more trustworthy endpoint for a process that previously depended on scattered paperwork and manual follow-up.