Isfandyar khan's Work | ContraWork by Isfandyar khan
Isfandyar khan

Isfandyar khan

Production ready AI agents & SaaS platforms built for scale

    4
    Followers
Followed by Kraig M, Sagar N, and Moch Virgiawan C

Karachi, Pakistan

WorkPostsServicesAbout

Karachi, Pakistan

Cover image for Moving From Prototype to Production Our
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.
0
72
Cover image for KovaRisk: Turning a Risk Monitoring
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
87
Cover image for From Prototype to Production: Building
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
90
Cover image for StudySpace — AI-Powered Study &
StudySpace — AI-Powered Study & Learning Platform Transforming Course Materials Into Personalized, Exam-Ready Learning StudySpace is an AI-powered learning platform designed to turn unstructured academic content into organized, personalized study resources. Instead of manually working through lecture slides, textbooks, PDFs, and past examinations, students can upload their materials and use AI to transform them into an interactive learning environment. The Challenge Students often have plenty of study material but lack an efficient way to turn it into structured preparation. Common challenges include: Large volumes of disconnected course material Passive note-reading instead of active recall Difficulty identifying weak areas Generic study tools that don't adapt to individual goals Limited connection between generated study content and original source material StudySpace was designed to bring these activities into one intelligent workspace. AI-Powered Content Processing Students can upload PDFs, lecture materials, textbooks, and previous exams. The platform processes these documents through a multi-stage AI pipeline that identifies: Topics Concepts Themes Important sections Exam-relevant information The extracted knowledge then becomes the foundation for the student's personalized study environment. Automated Study Material StudySpace generates learning resources directly from uploaded content, including: Condensed study notes Spaced-repetition flashcards Practice questions Topic-based quizzes Exam simulations Generated content remains connected to the original material, allowing students to trace information back to its source. Personalized Study Planning The platform adapts the learning experience around each student's objectives. During onboarding, students can define their: Academic level Learning goals Exam date Study preferences Areas requiring additional attention The system then builds a personalized study plan and adjusts recommendations as the student's progress changes. Course Workspace Each uploaded document becomes an interactive study environment. Students can navigate through topics, review AI-generated notes, access source references, practice flashcards, and complete quizzes from a centralized workspace. The interface brings the complete learning workflow into one structured experience rather than requiring students to switch between multiple study tools. SpaceBot & Personalized Dashboard StudySpace also includes an AI learning assistant designed to answer questions using the student's own uploaded materials. SpaceBot can adapt its communication style based on the student's preference, including: Friendly explanations Formal academic responses Socratic questioning The dashboard provides an overview of the student's current learning activity, including: Today's study sessions Exam countdowns Upcoming objectives Weak topics Progress indicators What We Built The final platform included: AI-powered document processing PDF upload and content extraction Automated topic discovery AI-generated notes Flashcard generation Adaptive quizzes Personalized study planning Source-level content attribution Exam simulation AI study assistant Progress tracking Personalized onboarding The backend was designed around a multi-stage processing pipeline capable of handling document extraction, content generation, study planning, and adaptive review. Results The platform delivered measurable improvements across the study workflow: 90% reduction in time required to transform uploaded material into structured study resources 3× improvement in reported retention through flashcard and quiz engagement 100% source traceability for generated learning content A centralized learning environment combining content processing, AI assistance, planning, and assessment Technology Stack Frontend: React, Vite, Tailwind CSS Backend: FastAPI Database: PostgreSQL Processing: PyMuPDF, Celery, Redis AI: OpenAI GPT-4o Authentication: Clerk Infrastructure: Docker The Result StudySpace turned static academic content into an interactive, personalized learning system. Instead of simply giving students another place to store notes, the platform creates a workflow that moves from: Upload → Understand → Organize → Practice → Track → Prepare The result is an AI-powered study environment built around the student's own material, goals, and learning progress.
0
75