Production-ready AI agents and SaaS built to scale reliably.
$50k+
Earned
4x
Hired
134
Followers
Production-ready AI agents and SaaS built to scale reliably.
Multi-Tenant CMS and Website Platform for Multi-Brand Organizations
Description:
A production-ready multi-site CMS that lets one team run many branded websites from a single admin. It includes tenant isolation, a block-based page builder, automated WordPress migration, AI-assisted page building, and AWS infrastructure.
The challenge:
The client needed to manage many separate websites from one CMS. Each site had its own domain, theme, content and users. The platform had to do four things at once:
• keep tenants fully isolated from each other
• give editors reusable building blocks instead of one-off pages
• make moving existing WordPress sites in fast instead of a manual rebuild
• run reliably in production, not just work as a prototype
What I built:
1. Multi-tenant Payload CMS.
Tenant isolation, per-tenant domains and themes, and role-based access control, so every brand stays separate within one admin.
2. Block-based page builder.
Reusable content blocks, plus blog and form support, so editors build pages without a developer.
3. WordPress migration automation.
Existing sites are imported automatically, and content import and export runs through structured workflows.
4. AI-assisted page and component generation.
Claude turns screenshots and layouts into ready-to-use pages and components, which speeds up new-site setup.
5. Performance and SEO.
Static site generation with Next.js, semantic HTML, and Tailwind CSS for fast, search-friendly pages.
6. Production AWS infrastructure.
Defined in CloudFormation with RDS (PostgreSQL), S3, CloudFront, ACM, SES, Lambda and WAF, with separate staging and production environments.
7. Production-readiness work.
Improvements to admin UX, data workflows, environments and infrastructure security, plus Playwright in the tooling.
The outcome:
The product went from concept to a production-ready multi-site platform. One team can now launch and run many branded websites from one place. Each site is isolated, fast and SEO-friendly. Migrations and new builds take a fraction of the manual effort.
Key takeaway:
A white-label CMS only scales when flexible content tooling comes with real production engineering: isolation, migrations, infrastructure and security.
Good fit for: agencies, franchises, multi-brand organizations, and SaaS teams managing many websites from one platform.
Skills and tools used:
Next.js · Payload CMS · PostgreSQL · Tailwind CSS · AWS · CloudFormation · CloudFront · RDS · S3 · Lambda · SES · WAF · Playwright · Claude API · Multi-Tenant SaaS · Headless CMS · WordPress Migration · SEO
1
566
KovaRisk: When the Interface Knew More Than the System
──────────────────────────────────────────
The Expert in the Room
Compliance officers don't struggle to understand risk. They struggle to act on it fast enough.
The team behind KovaRisk understood this precisely. They had spent years inside financial institutions watching the same dysfunction repeat: alerts buried in spreadsheets, investigations tracked in email threads, audit trails reconstructed after the fact. They knew
what the interface needed to feel like because they'd lived with the one that didn't.
So they built it. Fast. Exactly as they'd imagined it.
What emerged was sharp: a risk monitoring dashboard with filterable alert feeds, entity profiles with 12-month risk trajectories, a rule engine with toggle controls, and an audit log that felt immutable. The scenario switcher let compliance teams stress-test
different alert load states. The side panel made investigations feel contained and intentional.
It looked like a system that had survived production.
It hadn't been asked to yet.
──────────────────────────────────────────
What Existed Was a Strong Interface - Not a System
Every alert in KovaRisk was generated at startup. Every risk score was computed by a random seed function. Every status change - Investigating, Resolved, Escalated - lived in component state. Every timeline event was appended to an in-memory array. Every rule toggle
disappeared on refresh.
The audit log recorded nothing. The export downloaded a snapshot of what React was holding at that moment. The entity risk history was a curve drawn from a formula, not a record.
The logic was there. But it had nowhere to live.
A compliance officer investigating a high-risk wire transfer would open the side panel, read the plain-English rule explanation, mark the alert as Investigating, add an internal note - and lose every one of those actions the moment they refreshed the browser. No
colleague could see what they'd done. No regulator could verify it had happened.
In financial compliance, that's not a UX problem. It's a liability.
The prototype validated the workflow brilliantly. It exposed exactly how a compliance team would move through their day. But three things were missing: a source of truth, a coordination layer, and a trail that could be audited under pressure.
──────────────────────────────────────────
They Didn't Need More Features - They Needed a System Behind the Interface
The team came with a clear idea and a working prototype. What they needed was the architecture that made the prototype a product - the layer that turned interface actions into durable facts.
Not a rebuild. A foundation.
──────────────────────────────────────────
The Layer That Made It Dependable
Data Models: Giving State a Home
The first thing to reconstruct was where the data should actually live.
KovaRisk's frontend implied a clear schema - alerts, entities, rules, audit events - but none of it persisted. The production system needed a PostgreSQL core with five primary entities:
• Alert — with foreign keys to Entity, Rule, Transaction, and a JSONB timeline column for ordered event history
• Entity — with risk tier, jurisdiction metadata, and a one-to-many relationship to RiskScore snapshots
• Rule — with active/disabled state, trigger thresholds, false-positive tracking, and a versioning mechanism so changes to rules didn't retroactively alter historical alerts
• AuditEvent — append-only, with actor ID, action type, target reference, and a server-generated timestamp that clients cannot modify
• InternalNote — owned by an alert, with authorship and a soft-delete flag to preserve compliance integrity
Every status change, note, escalation, and flag the UI handled ephemerally became a write to this schema.
The Alert Generation Engine: Replacing the Seed Function
In the prototype, 85 alerts appeared because a loop ran 85 times at startup.
In production, alerts are the output of a Transaction Monitoring Service - a background process that runs continuously against incoming transaction streams.
This service:
• Evaluates each transaction against every active Rule definition
• Computes a risk score using rule weights, entity risk tier, jurisdiction flags, and behavioral baselines
• Creates an Alert record only when a threshold is breached
• Emits an event to a notification queue for high-risk triggers
The rule engine the UI let users toggle wasn't decorative. Each rule mapped to an evaluation function in the monitoring service. Disabling a rule didn't just grey out a card - it removed it from the active evaluation set. Re-enabling it didn't retroactively generate
alerts it would have caught; it resumed from the point of activation. That distinction mattered for regulatory defensibility.
──────────────────────────────────────────
Async Workflows: The Operations the UI Implied But Couldn't Sustain
Several interactions in the prototype implied workflows that couldn't complete synchronously.
Escalation - When an alert was escalated, the UI changed a status badge. In production, escalation triggers a queue job that: notifies the senior compliance officer via a configured channel, creates a case record linking the alert, and starts a response SLA timer.
The UI reflects the outcome - it doesn't produce it.
Scheduled Screening - The Sanctions Screening Match rule in the prototype was static. In production, it's a nightly job that re-screens all active entities against updated OFAC, EU, and UN sanctions lists - generating new alerts if a previously clean entity now
appears. The results feed back into the alert pipeline.
Report Export - The dashboard's Export Report button downloaded a text file of whatever React was holding in memory. In production, report generation is an async job: the user requests the report, the job runs server-side against the live database, and a download
link is returned when ready. The content is a verifiable, timestamped record - not a UI snapshot.
──────────────────────────────────────────
The Audit Log: From Feed to Fact
The prototype's audit log was populated by a generateAuditLog function. It looked comprehensive and immutable. It was neither.
Production audit events are written by the API layer on every state-modifying operation - before the response is returned to the client. The table is append-only. No update operations are permitted on AuditEvent records. Timestamps are server-generated in UTC and
stored with full precision. Actor identity comes from the authenticated session, not from a string the client sends.
The audit log the interface displayed was a simulation of accountability. The production version is the accountability.
──────────────────────────────────────────
Tech Stack
1. Frontend: React + Vite, React Router v6, Recharts, React Context + local state, TanStack Query
2. Backend: Node.js + TypeScript, Fastify, Prisma, PostgreSQL, Redis, BullMQ, Passport.js + express-session
3. Infrastructure: AWS ECS / Railway / Render, S3, AWS Secrets Manager / Doppler, Sentry + Datadog, GitHub Actions
4. External Integrations: OFAC / ComplyAdvantage, Refinitiv World-Check, SendGrid / SMTP, Webhooks
──────────────────────────────────────────
From Interface to System
The prototype answered the right questions. It proved the workflow was sound, the information hierarchy was correct, and the alert investigation pattern worked the way compliance officers needed it to.
What it couldn't answer was: what happens when two investigators open the same alert simultaneously? What happens when a rule change needs to take effect immediately across 200 pending alerts? What happens when a regulator asks for every action taken on a specific
entity over the past 18 months?
Those questions don't live in the interface. They live in the system.
KovaRisk's interface was always strong. What it needed was the architecture to make it real - persistent, coordinated, auditable, and defensible under scrutiny.
The logic existed from the beginning. We gave it somewhere to live.
2
2.3K
Case Study: From Prototype to Production — Building a Credit Management Platform for Ad Operations
The Starting Point
The founder wasn't guessing the problem. They had spent years inside the ad-credit ecosystem, managing wallet balances across regions, reconciling top-ups via bank wire and stablecoin, chasing compliance documents, and watching campaigns stall because a pixel stopped firing at 2am.
They knew exactly what a credit management platform needed to look like. So they built one.
Using Figma wireframes translated directly into a React frontend, they shipped a working prototype in days. Two portals were created. One for clients managing wallets and ad accounts, and one for internal operators handling treasury, compliance, and risk. It included real-time spend charts, AI-driven anomaly detection banners, a work queue for ops teams, and an embedded AI assistant that could answer questions about balances, compliance status, and pixel health.
The prototype proved the concept. Clients could see their wallet balances, request top-ups, allocate funds to ad accounts, and track campaign performance. Admins could manage treasury operations, review KYB pipelines, monitor risk scores, and process a prioritized work queue. The domain logic was sound. The UX was sharp.
But the system was never designed to survive real load.
What Started Breaking
The prototype worked on mock data. Every API call returned hardcoded arrays after a random delay. There was no backend. No database. No real authentication. The login screen accepted any email and assigned a role based on a toggle switch. Session state lived in localStorage as a raw JSON blob.
This was fine for demos. It stopped being fine the moment real money entered the picture.
The specific fractures:
1. No transactional integrity. Wallet balances, top-ups, fund transfers, and ad account allocations were all simulated. In a live system, a transfer of $25,000 from a master wallet to a regional sub-wallet is not a UI state change. It is a financial transaction that requires atomicity, audit trails, and rollback capability. The prototype had none of this.
2. Compliance was cosmetic. KYB document statuses were static labels. In production, document verification involves third-party identity providers, expiration tracking, automated re-upload reminders, and regulatory audit logs. The prototype rendered badges like "Verified", "Pending", and "Missing", but nothing enforced the state machine behind them.
3. Risk scoring was decorative. The AI risk badges showed tooltips like "Large P2P transfer detected, document expiring", but these were string literals, not outputs from a scoring model. Real risk assessment requires transaction pattern analysis, velocity checks, cross-referencing compliance status, and escalation workflows that route to the right ops agent.
4. The work queue had no backend. Urgent items like "$45,000 P2P transfer anomaly" appeared in the queue, but resolving them was just a frontend state toggle. There was no case history, no assignment logic, no SLA tracking, and no integration with the compliance or treasury systems that actually needed to act on these events.
5. Multi-tenancy was absent. The platform served one mock client and one mock admin. Scaling to dozens of clients, each with their own wallets, sub-wallets, ad accounts, compliance profiles, and credit limits, required data isolation, permissioning, and tenant-aware queries that did not exist.
6. Ad platform integration was faked. TikTok metrics like impressions, clicks, ROAS, and pixel health were all static datasets. Production requires OAuth-based API integrations, rate-limited data syncing, webhook listeners for pixel status changes, and graceful degradation when platform APIs go down. The founder understood all of this. The prototype was never meant to be the product. It was meant to prove that the product was worth building.
Why They Brought In a Team
The gap between the prototype and production was not a matter of fixing bugs. It was an architecture problem.
The founder needed:
- A real backend with transactional guarantees for financial operations
- A compliance engine that could enforce document workflows across jurisdictions
- A risk system that could ingest transaction data and surface actionable alerts, not static strings
- Multi-tenant data architecture with proper isolation and access control
- Ad platform integrations that could handle real API contracts, rate limits, and failures
- Observability including logging, monitoring, and alerting so the ops team could trust the system under load
They did not need someone to rewrite the frontend. They needed someone to build the system underneath it.
What We Delivered
Financial Operations Layer
We replaced the mock API with a transactional backend. Every wallet operation, including top-ups, transfers, allocations, and refunds, now runs through an auditable pipeline with:
- Atomic balance updates with optimistic locking
- Double-entry ledger for every fund movement
- Idempotent transaction processing to prevent duplicate charges
- Full audit trail with actor, timestamp, and before and after state
Top-up requests now flow through a verification pipeline with submission, proof-of-payment upload, approval, and balance credit. Each step is recorded and reversible.
Compliance and KYB Engine
- We built a document lifecycle system that replaces static badges with enforced state transitions:
- Documents move through missing → uploaded → under_review → verified → expired with rules governing each transition
- Expiration monitoring triggers automated client notifications
before deadlines
- Third-party identity verification integration for director ID matching
- Jurisdiction-aware requirements where different regions require different document sets
- Audit-grade logging for every status change, reviewer action, and override
The KYB pipeline now routes cases to specific compliance agents based on workload, region, and verification type.
Risk and Anomaly Detection
We replaced hardcoded risk labels with a scoring system that evaluates:
- Transaction velocity based on spend acceleration versus historical baseline
- P2P transfer patterns and threshold breaches
- Compliance status correlation, such as expired documents combined with high spend
- Account dormancy detection where inactivity triggers review
Risk scores update in near real time. High-risk events automatically generate work queue items with priority, context, and suggested actions.
Work Queue and Case Management
We transformed the frontend-only task list into an event-driven operations system:
- Events from treasury, compliance, and risk systems automatically create queue items
- Assignment logic routes items to the right agent based on type, region, and capacity
- SLA tracking with escalation rules for overdue items
- Case history that records every action, note, and resolution
- Enforced status transitions so items cannot be resolved without required actions
Multi-Tenant Architecture
We designed the data layer for tenant isolation from the ground up:
- Each client organization has isolated wallets, documents, ad accounts, and transaction histories
- Role-based access control separates client-facing and admin-facing data
- API endpoints are tenant-scoped to prevent cross-tenant data leakage
- Admin views aggregate across tenants with proper permissioning
Ad Platform Integration
We built a sync layer for TikTok Ads with an architecture that supports additional platforms:
- OAuth-based account linking with token refresh management
- Scheduled metric pulls with rate limit awareness and backoff
- Pixel health monitoring via event signal tracking instead of static labels
- Graceful degradation where stale data is clearly labeled if APIs fail
Observability
We added the infrastructure the ops team needs to trust the system:
- Structured logging for every financial operation, compliance action, and API call
- Health dashboards for backend services, integration sync status, and queue throughput
- Alerting on anomalies such as failed transactions, sync delays, and SLA breaches
- Error tracking with business context, not just stack traces
The Outcome
The system went from a prototype that could demo well to a platform that could process real money, enforce real compliance, and surface real risk under real load.
What changed:
- Financial operations now run with transactional guarantees. Wallet balances are accurate, auditable, and reconcilable.
- Compliance is enforced, not displayed. Document workflows follow regulated state machines with full audit trails.
- Risk detection is continuous and contextual. The ops team acts on scored alerts instead of static labels.
- The work queue drives operations. Events flow in automatically, route correctly, and track resolution against SLAs.
- Multi-tenancy works. New clients onboard into isolated environments without architectural changes.
- Ad integrations sync reliably. When they fail, the system clearly shows it instead of masking stale data.
The founder’s instinct was right from the start. The domain model, the UX, and the operational workflows all held up. What we built was the engineering foundation that made it dependable.
The system worked until it didn’t. Not because the idea was flawed, but because it was never designed to handle this level of complexity. The prototype proved the product. The production system proved it could scale.
Tech Stack Overview
1. Backend: Node.js (NestJS)
2. API: GraphQL
3. Auth: Auth0
4. Database: PostgreSQL
5. Cache/Queue: Redis
6. Search: Elasticsearch
7. Infrastructure: AWS
8. Containers: ECS Fargate
9. CI/CD: GitHub Actions
10. IaC: Terraform
11. Integrations: Stripe
12. Risk Engine: Python (FastAPI)
13. ML Pipeline: scikit-learn
14. AI Assistant: OpenAI GPT-4
15. Vector Store: Pinecone
2
2.3K
😍 This the best I have done in health industry - A SaaS platform: https://treatmentnotes.com/
🚀 Built an AI-powered behavioral health documentation platform designed for real clinical workflows. The system supports AI generated notes from live conversations, uploaded transcripts, and custom knowledge-base logic tailored to mental health and addiction treatment. It was designed for secure, scalable healthcare use with HIPAA ready architecture and EMR integration support.
💯 Complete Tech Stack:
AI Summarization, Clinical Nuance Detection, FastAPI, Vite, React, AWS Bedrock, Anthropic Claude, PostgreSQL, pgvector, Vector Database, Retrieval-Augmented Generation (RAG), AI Agent Architecture, HIPAA Compliant Cloud, Speech-to-Text API, LLM Fine-tuning, Healthcare Interoperability, HL7/FHIR Integration, Serverless Backend, Semantic Search, Private LLM Deployment, Encryption at Rest, Python Backend Development.
🧠 What do you say Contra Community?
ESG reporting is a workflow problem as much as a data problem: teams need applicability rules, evidence, consolidation, review, and approvals before a report is ready.
For OriginSustain, I built NestJS/TypeScript backend services, PostgreSQL and Redis/BullMQ processing, and AWS/Docker delivery with CI/CD. OpenAI API and RAG support part of the reporting flow. The screens here are from the product’s illustrative command center; the numbers are demo values, not client outcomes.
The full backend case study: https://contra.com/p/WvNXbmQR-origin-sustain-or-multi-tenant-esg-reporting-backend
5
1.4K
A good donation flow needs dependable systems behind the screens. For Gabriel SGO, I built the NestJS/PostgreSQL backend for donor and school workflows, with PayPal donation processing, Redis/BullMQ background jobs, Mailgun email, and AWS delivery.
The public experience helps Ohio donors estimate a contribution, choose a school, and understand the tax-credit process. I documented the backend work and real site screens here: https://contra.com/p/Ls6L2o7Y-gabriel-sgo-or-donation-and-school-allocation-backend
Production ready AI agents & SaaS platforms built for scale
New to Contra
Production ready AI agents & SaaS platforms built for scale
AI Behavioral Health Documentation Platform
AI-Powered Clinical Documentation Built for Behavioral Healthcare Workflows
Overview
Designed an AI-powered documentation platform focused on real clinical workflows across mental health and addiction treatment. The platform transforms live conversations and uploaded transcripts into structured clinical documentation while using custom knowledge-base logic to maintain domain-specific context.
The architecture was designed around security, scalability, healthcare interoperability, and AI-assisted clinical workflows, providing a foundation for integration with existing EMR systems.
The Challenge
Behavioral health documentation requires more than basic transcription. Clinical notes need to capture nuance, context, treatment terminology, and relevant patient information while fitting naturally into existing healthcare workflows.
The platform needed to:
Convert conversations into structured clinical notes
Understand behavioral health and addiction-treatment terminology
Ground AI outputs in custom clinical knowledge
Support transcript and speech-based inputs
Maintain secure handling of sensitive healthcare data
Provide a scalable foundation for EMR interoperability
AI-Powered Documentation
The system combines speech-to-text, LLM-based summarization, clinical nuance detection, and retrieval-augmented generation (RAG) to transform raw conversations into meaningful documentation.
Custom knowledge-base logic and semantic search help ground generated content in relevant clinical information rather than relying solely on general-purpose model knowledge.
Intelligent AI Architecture
The platform uses an agent-oriented architecture combining:
AI summarization
Clinical context and nuance detection
RAG pipelines
Semantic search
Vector-based knowledge retrieval
Private LLM deployment
LLM fine-tuning capabilities
Custom healthcare knowledge bases
This creates a flexible foundation for specialized behavioral-health documentation workflows.
Healthcare-Ready Infrastructure
Security and interoperability were considered at the architecture level, including:
HIPAA-ready cloud architecture
Encryption at rest
Secure backend infrastructure
PostgreSQL + pgvector
Healthcare interoperability support
HL7/FHIR integration readiness
EMR integration support
Serverless backend architecture
Technology Stack
Frontend: React, Vite
Backend: Python, FastAPI
AI/LLM: AWS Bedrock, Anthropic Claude, AI Agents
AI Infrastructure: RAG, Vector Database, pgvector, Semantic Search, LLM Fine-tuning
Database: PostgreSQL
Healthcare: HL7/FHIR, EMR Integration
Cloud & Security: AWS, HIPAA-ready architecture, Encryption at Rest
Speech: Speech-to-Text APIs
The Result
A scalable AI clinical documentation platform built specifically around behavioral healthcare workflows—combining conversational AI, clinical knowledge retrieval, secure infrastructure, and healthcare interoperability into a unified system.
1
1
147
From Prototype to Production: Building a Scalable Credit Management Platform for Ad Operations
Transforming a Conceptual Ad-Credit System Into a Production-Ready Financial Operations Platform
The platform was designed around a complex operational challenge: managing advertising credit, wallets, compliance, risk, and campaign activity across multiple clients and regions.
The original product concept came from deep experience in the ad-credit ecosystem. The workflow covered everything from wallet funding and regional allocations to KYB verification, transaction monitoring, campaign performance, and operational support.
A working React prototype had already demonstrated the core experience.
It included separate portals for clients and internal operations teams, with features such as:
Wallet and balance management
Ad account allocation
Top-up requests
Campaign performance dashboards
Compliance monitoring
Risk indicators
Operations work queues
AI-assisted support
Treasury management
The product vision was validated. The next challenge was creating the infrastructure required to operate it with real financial data.
From Mock Data to Real Infrastructure
The prototype relied heavily on simulated API responses and frontend state.
That worked well for demonstrating workflows, but financial operations require persistent data, transactional integrity, authentication, auditability, and controlled access.
We rebuilt the underlying architecture while preserving the validated frontend experience.
Financial Operations & Wallet Management
We introduced a transactional backend for core financial operations, including:
Wallet top-ups
Fund transfers
Regional wallet allocation
Ad account funding
Refunds
Balance reconciliation
A double-entry ledger provided a structured record of every movement of funds.
Transactions were designed with:
Atomic balance updates
Optimistic locking
Idempotent processing
Transaction history
Actor tracking
Before-and-after state records
Full auditability
Top-up requests were also converted into structured workflows covering submission, payment verification, approval, and balance crediting.
Compliance & KYB Management
The prototype represented compliance through simple status indicators.
We replaced those static states with a structured KYB lifecycle.
Documents could progress through stages such as:
Missing → Uploaded → Under Review → Verified → Expired
The system introduced rules governing each transition, along with:
Document expiration monitoring
Automated notification workflows
Identity verification integrations
Region-specific compliance requirements
Reviewer activity tracking
Compliance overrides
Audit history
Cases could also be routed to compliance agents according to factors such as workload, region, and verification requirements.
Risk & Anomaly Detection
Static risk indicators were replaced with a dedicated risk evaluation layer.
The platform could evaluate multiple signals, including:
Transaction velocity
Changes in spending behavior
P2P transfer patterns
Threshold breaches
Account activity
Compliance status
Dormancy indicators
Risk conditions could generate prioritized operational alerts with relevant context and recommended actions.
This connected the risk engine directly to the operations workflow rather than treating risk as a visual indicator inside the dashboard.
Operations Work Queue
The original work queue was primarily frontend-driven.
We transformed it into an event-based operations system.
Events from financial, compliance, and risk workflows could automatically create operational tasks.
The system supported:
Intelligent task assignment
Regional routing
Capacity-based allocation
SLA monitoring
Escalation workflows
Case history
Required-action validation
Resolution tracking
Every operational case could maintain a complete history of actions, notes, and status changes.
Multi-Tenant Architecture
The production system needed to support multiple client organizations while keeping their financial and compliance data isolated.
We introduced tenant-aware architecture across the data and API layers.
Each organization could maintain its own:
Wallets
Ad accounts
Transactions
Compliance records
Credit limits
Operational history
Role-based permissions separated client-facing functionality from internal administrative operations, while tenant-scoped API access helped prevent cross-organization data exposure.
Advertising Platform Integration
We also replaced simulated advertising metrics with a dedicated integration layer.
The architecture supported TikTok Ads through:
OAuth account authorization
Token refresh handling
Scheduled metric synchronization
Rate-limit awareness
Retry and backoff strategies
Pixel health monitoring
API failure handling
When an external platform became unavailable, the system could clearly identify stale information rather than presenting outdated metrics as current.
Observability & Infrastructure
Production financial systems require visibility across both technical and business operations.
We introduced:
Structured application logging
Transaction monitoring
Integration health checks
Queue monitoring
SLA alerts
Error tracking
Backend service dashboards
Synchronization monitoring
This gave operations teams visibility into both application health and business-critical events.
AI & Risk Intelligence
The platform also incorporated intelligent services into the broader architecture.
The risk layer was supported by a Python-based service and machine-learning pipeline, while an AI assistant provided a conversational interface for accessing relevant operational information.
The architecture included:
Python / FastAPI risk services
scikit-learn ML workflows
OpenAI-powered AI assistant
Pinecone vector storage
These capabilities were integrated into the broader platform rather than operating as isolated AI features.
Technology Stack
Backend: Node.js, NestJS
API: GraphQL
Authentication: Auth0
Database: PostgreSQL
Caching & Queues: Redis
Search: Elasticsearch
Cloud Infrastructure: AWS, ECS Fargate
CI/CD: GitHub Actions
Infrastructure as Code: Terraform
Payments: Stripe
Risk Engine: Python, FastAPI
Machine Learning: scikit-learn
AI: OpenAI GPT-4
Vector Database: Pinecone
The Outcome
The platform evolved from a prototype designed to demonstrate the concept into a production-oriented system capable of supporting real financial and operational workflows.
The transformation introduced:
Transaction-safe financial operations
Structured compliance workflows
Continuous risk evaluation
Event-driven operations management
Multi-tenant architecture
Live advertising integrations
Automated monitoring and alerts
AI-assisted operational intelligence
The original prototype had already established the product vision and user experience.
Our work focused on building the engineering foundation underneath it—turning simulated workflows into persistent, secure, scalable, and operationally reliable systems.
From an impressive prototype to a financial operations platform built for real-world complexity.
0
104
KovaRisk: Turning a Risk Monitoring Prototype Into a Production-Ready Fintech Platform
From Interactive Compliance Dashboard to Persistent Risk Intelligence System
KovaRisk started with a clear goal: give compliance teams a centralized way to monitor financial risk, investigate alerts, manage rules, and maintain reliable audit records.
The original prototype already had a strong product foundation. It included:
Risk and alert monitoring dashboards
Filterable alert feeds
Entity-level risk profiles
Historical risk trends
Configurable monitoring rules
Investigation workflows
Audit activity
Scenario-based testing
The interface effectively demonstrated how a compliance team could interact with the product.
The challenge was that most of the underlying functionality was still simulated.
The Gap Between the Prototype and Production
The frontend represented a complete risk-management workflow, but much of its state existed only inside the browser.
Alerts were generated when the application started. Risk scores were simulated. Status changes were stored in component state, and audit events existed only in memory.
Refreshing the application could erase an investigation update, internal note, or rule configuration.
For a financial compliance platform, persistence isn't simply a technical requirement. Investigations, decisions, and user actions need to remain traceable and verifiable.
The next phase was therefore focused on building the system behind the interface.
Building the Production Foundation
Structured Data Architecture
We translated the prototype's workflows into a persistent relational data model using PostgreSQL.
The architecture introduced dedicated entities for:
Alerts
Financial entities
Monitoring rules
Risk-score history
Audit events
Internal investigation notes
Transactions
Relationships between these entities allowed actions performed through the interface to become durable records rather than temporary frontend state.
Rule versioning was also introduced so historical alerts could remain associated with the conditions that existed when they were generated.
Real-Time Alert Generation
The prototype initially generated a predefined set of alerts.
We replaced this behavior with a transaction-monitoring architecture capable of evaluating incoming transactions against active compliance rules.
The system could:
Evaluate transactions against configured rules
Calculate risk scores
Consider entity and jurisdiction risk
Identify threshold breaches
Create persistent alert records
Trigger notifications for high-risk events
Rule controls in the dashboard became connected to the actual monitoring engine.
Disabling a rule affected future evaluations rather than simply changing the appearance of a UI component.
Asynchronous Compliance Workflows
Several actions required more than a simple frontend state change.
We introduced background processing for operational workflows such as:
Alert Escalation
Escalating an alert could initiate notifications, create a corresponding case, and begin tracking the response timeline.
Scheduled Screening
Entities could be periodically screened against external sanctions data, with newly identified matches feeding back into the alert workflow.
Report Generation
Instead of exporting whatever happened to be loaded in the browser, reports were generated server-side from the current database state and made available once processing completed.
This created a more reliable separation between the user interface and the underlying business operations.
Building a Reliable Audit Trail
One of the most important parts of KovaRisk was transforming the audit interface from a simulated activity feed into a persistent record of system events.
Audit events were generated at the API layer whenever important state changes occurred.
Each event captured:
Authenticated user
Action performed
Target entity
Event type
Server-generated timestamp
Relevant activity context
The audit records were designed to be append-only, preventing normal application workflows from modifying historical events.
This gave compliance teams a much more dependable record of how alerts and investigations progressed.
Technology Stack
Frontend: React, Vite, React Router, Recharts, TanStack Query
Backend: Node.js, TypeScript, Fastify, Prisma
Database & Processing: PostgreSQL, Redis, BullMQ
Authentication: Passport.js, Express Session
Infrastructure: AWS ECS, Railway / Render, Amazon S3
Security & Monitoring: AWS Secrets Manager, Doppler, Sentry, Datadog
Integrations: OFAC / ComplyAdvantage, Refinitiv World-Check, SendGrid / SMTP, Webhooks
The Result
KovaRisk evolved from an interactive compliance prototype into a structured fintech risk-monitoring platform.
The interface remained focused on the workflows compliance teams needed, while the underlying architecture introduced:
Persistent data
Automated alert generation
Configurable rule processing
Background workflows
External screening integrations
Reliable report generation
Role-aware system operations
Persistent audit records
The key transformation wasn't adding more screens.
It was connecting every important interaction in the interface to a dependable backend process.
The prototype demonstrated how compliance teams should work. The production architecture made those workflows persistent, automated, and operationally reliable.
0
98
Moving From Prototype to Production
Our focus wasn't to redesign the product from scratch.
The original UX already reflected how performance teams actually work, so we preserved the existing product experience while rebuilding the underlying infrastructure.
Real-Time Data Infrastructure
We replaced static datasets with a structured ingestion architecture capable of receiving information from multiple sources.
The system was designed around:
GPS and wearable data
HRV and recovery metrics
Sleep information
Wellness submissions
Training-load records
External performance systems
Each integration required validation, normalization, and error handling so inconsistent or incomplete data wouldn't compromise the platform.
Live Performance Calculations
Static calculations were replaced with dynamic processing.
The platform could evaluate:
ACWR
Training-load trends
Readiness scores
Historical performance
Rolling training windows
Individual athlete baselines
This allowed performance metrics to evolve with the athlete instead of remaining fixed to predefined values.
Intelligent Performance Insights
We replaced simulated recommendations with a data-driven inference layer.
Insights were generated based on actual athlete conditions and predefined performance rules.
For example, when training load increased significantly while recovery indicators dropped below an athlete's baseline, the system could surface an appropriate risk signal rather than displaying a generic recommendation.
Role-Based Access
Athliq required different users to work with different levels of information.
We implemented role-based access so that:
Performance Directors could monitor squad-level performance
Sport Scientists could analyze training and performance metrics
Physiotherapists could access injury and return-to-play information
Coaches could focus on readiness and daily training
Athletes could access relevant individual information
Access restrictions were enforced at the system level rather than simply being controlled through the interface.
Monitoring & Reliability
Production systems need visibility when something goes wrong.
We introduced logging and monitoring across data ingestion, calculations, and system events.
The platform could identify issues such as:
Missing data
Delayed integrations
Invalid records
Calculation anomalies
Stale data sources
Application errors
This helped prevent outdated information from being presented as current performance data.
Technology Stack
Frontend: React 19, Vite, Tailwind CSS, Recharts, React Router
Backend: Node.js, Fastify
Database: PostgreSQL, TimescaleDB
Infrastructure: Redis, Vercel, Railway / Render, Supabase Storage
Integrations: Catapult, Polar, Garmin, Google Forms, Typeform
Authentication & Security: Auth0, Row-Level Security
Monitoring: Sentry, Datadog
The Result
Athliq transformed a fragmented performance-monitoring workflow into a centralized platform.
Instead of moving between multiple browser tabs, spreadsheets, forms, and communication channels, performance teams could access their core athlete information through a unified dashboard.
The platform provided role-specific views, continuously updated performance information, historical context, and actionable signals from integrated data sources.
More importantly, it created a shared data layer for coaches, sport scientists, physiotherapists, and performance directors.
The product evolved from a concept-validation prototype into a production-ready performance intelligence platform.
What Made the Project Interesting
The biggest challenge wasn't simply building another analytics dashboard.
It was translating real-world sports performance workflows into reliable software infrastructure.
The original product concept came from someone deeply familiar with the domain. Our role was to preserve that domain knowledge while introducing the engineering foundations required for scalability, reliability, security, and live data processing.
The result was a system designed around the questions performance teams actually need answered—not simply around the data available to them.
Athliq Today
Athliq has evolved into a multi-role sports performance platform supporting professional and university-level performance environments.
The platform brings together data from multiple sources and transforms it into role-specific performance insights, giving teams a centralized environment for monitoring readiness, training load, recovery, and athlete progression.
From a coach's notebook and fragmented data sources to a scalable performance intelligence platform.
Helping a mission-driven platform raise $180,000+ through a product we designed and built has been one of those outcomes that speaks for itself.
From product strategy and UX to development and launch, we built the infrastructure behind the experience - and it’s now processing real impact at scale.
The client’s words say the rest.
$180K+ raised. Built from design to deployment.
1
294
Landing Page for Origin - Intelligent ESG Compliance Infrastructure.
React and React Native Developer | Hybrid mobile application
5.0
Rating
5
Followers
React and React Native Developer | Hybrid mobile application
Madkhol is your smart, Sharia-compliant investment partner built to help you grow your wealth with confidence. In just minutes, you can open your portfolio, choose your strategy, and start investing with expert-backed guidance and advanced technology.
What does Madkhol offer?
• Comprehensive investment management powered by experienced specialists.
• Open your investment portfolio in under three minutes with a smooth, simple process.
• Personal consultation sessions to guide your financial decisions. • Flexible portfolios tailored to your goals and risk level.
• Diversified investment options designed for balance and long-term growth.
• Global investing across both local and international markets.
• Advanced strategies to help enhance your portfolio performance sustainably.
• Continuous learning through easy, in-app educational lessons.
Why choose Madkhol?
• A complete, end-to-end investment experience built to support your financial goals.
• Among the lowest investment fees in Saudi Arabia, with full transparency.
• Expert support to help you make informed and confident decisions.
• Industry-leading security standards to protect your data and investments.
• 100% Sharia-compliant investment solutions aligned with Islamic principles.
Madkhol smart investing that aligns with your goals and your values.
0
78
Wasl a USD banking app for MENA freelancers. Real US account & routing numbers, virtual and physical cards, and mid-market currency conversion so creators can get paid by Upwork, ACH, or wire and spend or convert instantly.
0
109
Market Intelligence for Financial Brands.
Tap Market Intelligence uses this platform daily to manage content across its brokerage, payments, banking, and community products, and now it's available to other financial brands.
0
77
A health & nutrition iOS app that helps users find high-protein, low-carb, and GLP-1-friendly meals at nearby restaurants. Features restaurant discovery with Yelp ratings, instant menu suggestions, a scan-the-menu tool, and daily calorie & macro tracking.