FADLtech Product Build

Building GobFrain: a production multi-model AI application from the ground up

From product concept and UX through AWS architecture, AI orchestration, billing, security, and production operations.

From product idea to a deployed application

GobFrain started with a simple observation: more people were asking the same question in multiple AI chatbots because they did not fully trust any single answer.

That creates friction. Users have to copy the same prompt into several tools, compare answers manually, decide which differences matter, and often pay for multiple subscriptions they may not fully use.

FADLtech founder Omar Fadl designed and built GobFrain to bring that workflow into one application. GobFrain sends a user's prompt to multiple AI models, presents the individual responses, and then uses a judge model to evaluate the answers, explain meaningful disagreements, and produce a combined response.

The product also uses a pay-as-you-go token model, so users can purchase usage directly instead of maintaining multiple underused AI subscriptions.

How GobFrain works

  1. 1

    The user chooses multiple AI models.

  2. 2

    GobFrain sends the same prompt to the selected models.

  3. 3

    Each model produces its own answer.

  4. 4

    A judge model evaluates the responses and synthesizes a combined answer.

  5. 5

    The user can inspect both the individual answers and the judge's conclusion.

The point is not simply to generate more answers. It is to make disagreement between models useful. When models materially disagree, GobFrain gives the user a structured way to see the differences and a synthesized answer that takes those differences into account.

See It In Action
GobFrain screenshot 1 of 5

The complete product, end to end

Omar designed and implemented the complete product, including the application architecture, frontend, backend, AWS infrastructure, AI orchestration, authentication, billing, security controls, administration, and production operations. GobFrain is deployed and publicly usable today.

  • Multi-model querying through Amazon Bedrock
  • Judge-model aggregation and synthesis
  • User-selectable AI models
  • Token-based pay-as-you-go billing
  • AWS Cognito authentication with MFA
  • Lemon Squeezy payments and webhook verification
  • Amazon Bedrock Guardrails
  • Saved chat history and conversation management
  • Custom user instructions
  • Responsive desktop and mobile experience
  • Admin user management, notifications, and analytics
  • Audit logging, monitoring, backups, and disaster-recovery planning

Architecture designed around the actual workload

Asynchronous multi-model pipeline

Querying several models in parallel and then running a judge model afterward can take longer than a typical web request — long enough that forcing it through API Gateway's request timeout was the wrong design.

Instead, the initial request reserves tokens, creates the chat and job records, and starts a worker Lambda in the background. The API returns immediately with a job identifier while the frontend polls for completion.

This also required deliberately controlling Lambda retry behavior, so a long-running job that already succeeded could not be retried and accidentally charge a user twice.

DynamoDB single-table design

Users, credits, chats, messages, jobs, settings, models, and administrative data all share one DynamoDB table, with the schema driven by the application's actual access patterns rather than relational normalization.

Short-lived job records use TTL expiration instead of extra indexing, keeping common reads fast and predictable.

Reserve-then-finalize token accounting

Because users can launch concurrent requests, billing cannot safely read a balance and then deduct from it. GobFrain reserves tokens atomically before model calls begin, using DynamoDB conditional writes, then reconciles the reservation against actual usage once the pipeline finishes.

That prevents race conditions, negative balances, and AI-provider spend on requests a user cannot afford.

Security treated as production engineering

After the core product was functioning, Omar performed a dedicated security-hardening pass rather than treating “it works” as “it is ready.”

  • AWS WAF rules
  • Content Security Policy headers
  • Zod input validation
  • Strict origin/CORS validation
  • Secrets Manager for payment credentials
  • IAM policies scoped to specific resources
  • XSS sanitization
  • Secure random identifiers
  • Payment-webhook signature verification
  • DoS-resistant throttling

Amazon Bedrock Guardrails add another layer around AI usage. GobFrain surfaces meaningful guardrail feedback when content is blocked, so users can distinguish a deliberate safety decision from a generic application failure.

Built for independent deployment and operations

The AWS infrastructure is defined in TypeScript with AWS CDK and separated into four intentional stacks, reducing deployment blast radius and keeping dependencies explicit. A frontend-only change can be deployed without touching authentication or the database.

DatabaseAuthAPIFrontend
  • AWS X-Ray tracing on Lambda functions
  • Structured API Gateway logging
  • CloudFront access logging
  • Administrative audit logging
  • CloudWatch alarms
  • AWS Backup with cross-region copies
  • Documented disaster-recovery procedures and restore drills

Product decisions informed by real use

GobFrain was iterated based on actual user feedback rather than only a predefined feature list. Examples include:

  • Making entire model-selection cards clickable rather than requiring a small checkbox
  • Adding expand/collapse controls so multiple long model responses are easier to scan
  • Collapsing long user prompts so responses remain prominent
  • Adding a one-click “copy all responses” action
  • Preserving collapsed chat-history groups across sessions
  • Adding prompt character-count feedback before users reach a limit

Accessibility is treated as an application concern rather than a final checklist, with reusable accessibility components, semantic structure, keyboard support, focus management, and screen-reader announcements for dynamically arriving model responses.

Personalization without compromising model comparison

GobFrain supports Custom Instructions that let a user define background context, tone, and response preferences once. That logic is centralized into a single system-prompt builder and applied consistently to every selected model and to the judge.

Allowing different personalization behavior between models could bias the comparison itself — so the architecture supports personalization without introducing inconsistent prompting across the evaluation pipeline.

Technology stack

Frontend

React 18 · Vite · TypeScript · Tailwind CSS · shadcn/ui

Backend

AWS Lambda · Node.js · TypeScript · API Gateway

Database

Amazon DynamoDB (single-table design)

Authentication

Amazon Cognito Hosted UI · MFA

AI

Amazon Bedrock · Judge-model synthesis · Bedrock Guardrails

Payments

Lemon Squeezy · Verified webhooks · Token-based billing

Infrastructure & Operations

AWS CDK · CloudFront · AWS WAF · CloudWatch · X-Ray · AWS Backup · Audit logging

What this demonstrates for clients

GobFrain is a FADLtech product build, not a client case study. It is included here because it demonstrates the kind of end-to-end application ownership FADLtech can provide.

The project required more than writing application code. It required turning a product idea into:

  • a usable product workflow
  • a scalable cloud architecture
  • an AI orchestration layer
  • secure authentication
  • transactional billing
  • responsive user experience
  • production security controls
  • infrastructure as code
  • monitoring and auditability
  • backup and recovery procedures
  • iterative improvement from real user feedback

FADLtech can take a bounded software idea from architecture through working production software — while making the engineering decisions required to operate it responsibly after launch.

See the product

GobFrain is publicly available and free to try.

View Live Product (opens in a new tab)

Need a custom application built?

If you have a business process, internal tool, customer application, or AI-enabled software idea that needs experienced technical ownership, FADLtech can help define the right first version and build a practical path to production.