Freelance Software Architects in KarachiFreelance Software Architects in Karachi
ProjectsPeople
Ehtasham Ali's avatar
Ehtasham Ali
proKarachi, Pakistan
Production-ready AI agents and SaaS built to scale reliably.
$5k+
Earned
2x
Hired
22
Followers
Production-ready AI agents and SaaS built to scale reliably.
Cover image for KovaRisk: When the Interface Knew
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.
0
63
Cover image for Project Overview: Conduit's Interoperable Orchestration Platform
Project Overview: Conduit's Interoperable Orchestration Platform (IOP) seamlessly connects robots, machines, software, and sensors into a unified command center, enabling real-time factory floor automation and intelligence. It accelerates deployment, reduces integration costs, and transforms operations into fast, resilient, high-output systems. The Challenge Factory automation is often limited by: 1. Fragmented systems: Robots, machines, and sensors operate in silos, complicating coordination. 2. High integration costs: Connecting diverse equipment requires custom, expensive solutions. 3. Lack of real-time insights: Without live data, decision-making is slow, reducing efficiency and output. The Solution Conduit's IOP streamlines factory operations by: 1. Unified orchestration: Connects any robot, machine, software, or sensor into a single command center. 2. Rapid deployment: Automation workflows can be implemented in days, not months. 3. Live factory intelligence: Provides real-time insights to optimize productivity, reduce downtime, and enhance resilience. 4. Landing Page Description Conduit's Interoperable Orchestration Platform (IOP) connects every robot, machine, software, and sensor into a single command center. Deploy automation in days, gain real-time factory insights, and transform your operations into a fast, resilient, high-output powerhouse. What Our Client Got: We delivered a fully functional Conduit IOP with: - A unified command center connecting all robots, machines, software, and sensors. - Rapid deployment tools for automation workflows in days. - Real-time dashboards and analytics for actionable factory insights. Results Achieved: - 70% faster automation deployment across the factory floor. - 60% reduction in costly system integrations. - 85% improvement in operational efficiency and uptime. Conduit IOP is now transforming factories into high-output, resilient, and intelligent operations.
1
80
Cover image for From Instinct to Infrastructure: How
From Instinct to Infrastructure: How Athliq Went From Trainer's Notebook to Production Performance Platform ────────────────────────────────────────── The Person Who Understood the Problem Before Anyone Else Did Marcus had been a strength and conditioning coach for eleven years. He'd worked with professional football squads, Olympic track athletes, and NCAA programs. He knew exactly what was wrong with how performance data was managed, not because someone told him, but because he'd lived inside the problem every day. Every morning, he'd open four browser tabs, a spreadsheet, and a WhatsApp thread just to answer one question: Is this athlete safe to train today? HRV from one app. Sleep data from another. Yesterday's load from a Google Sheet. Wellness check-ins in a form nobody filled out consistently. Injury notes in a physio's personal folder. The picture was always incomplete, not because the data didn't exist, but because no system was designed to assemble it. He wasn't guessing the problem. He was the problem's daily victim. So he built something. ────────────────────────────────────────── The First Version Had Real Value What Marcus and a developer friend put together in six weeks was genuinely useful. A React frontend. Static JSON files simulating the data feeds he wished he had. A morning readiness dashboard showing each athlete's status: green, amber, red. ACWR calculations. A training plan view. A return-to-play protocol tracker. It looked like a real platform. It felt like one. When he demoed it to his performance director, the response was immediate: "This is what we've been trying to build for two years." The prototype surfaced something important. The problem wasn't that nobody had the data. The problem was nobody had designed the right lens to look at it through. Marcus had. His system organized information around the questions coaches actually ask, not the questions software vendors assume they ask. The initial build worked. For one squad. In static conditions. With fake data. And that was exactly the point where it started to matter, and exactly the point where its limitations became unavoidable. ────────────────────────────────────────── What Started Breaking The prototype had no backend. Data was hardcoded. Every "insight" was pre-written. The readiness scores didn't calculate; they were authored. When a second sport scientist saw the demo and said, "Can we plug in our GPS data?" there was no honest answer that didn't involve a complete rebuild. More specifically: The data layer was decorative. The JSON files looked real but required manual authoring for every scenario. There was no pipeline, no ingestion, no validation. Any live deployment would mean the dashboard showed stale or fabricated numbers, which in a performance context is worse than showing nothing at all. The AI insights were static strings. Every "AI-generated" recommendation was hardcoded text. In the prototype, this was fine. It demonstrated the concept. In production, it would mean the same insight appearing for every athlete regardless of their actual state, silently eroding clinician trust. The system had no concept of time. Training load calculations, ACWR ratios, wellness trends, all of these are temporal by definition. The prototype rendered them as snapshots. A real system needed rolling windows, historical comparison, and the ability to detect change over time. There was no role isolation. The role switcher in the UI was cosmetic. A physio and a performance director seeing the same underlying data with a CSS class change was not access control, it was theater. Nothing would survive a real integration. Real wearables return messy, incomplete, delayed data. The system had no error handling, no retry logic, no fallback states. The first real data feed would have broken the UI in ways that were invisible until they were catastrophic. The system was not wrong. It was early. ────────────────────────────────────────── Why They Didn't Just Fix It Themselves Marcus understood sport science. His developer understood React. Neither of them had built a production data system before, and that gap is not a skills deficiency, it is a domain specialization. What they needed was not someone to rewrite their frontend. The frontend was actually good. The visual hierarchy was sharp, the domain terminology was accurate, the workflows reflected how coaches genuinely think. That institutional knowledge was irreplaceable and not to be discarded. What they needed was: • A real-time data layer that could ingest from multiple sources reliably • A calculation engine that could run ACWR, load zone distributions, and readiness scoring against live data • A structured API contract between the front and back end • Authentication and role-based data scoping that actually enforced access boundaries • Observability, so when something silently broke, someone would know The prototype had proven the concept. The job now was to make the concept dependable. ────────────────────────────────────────── What We Actually Did We kept the frontend. Almost entirely. The visual design, the component architecture, the domain-accurate terminology, all of it stayed. We refactored the data layer, not the UI layer. The prototype's greatest strength was its UX fidelity to how coaches actually work, and we had no interest in rebuilding that from scratch. We built a real data ingestion pipeline. Rather than static JSON, we designed a service layer that could ingest from GPS units, HRV monitors, and wellness form submissions. Each source had its own adapter with validation, normalization, and error handling. Partial data was acceptable; silently wrong data was not. We replaced static calculations with a live computation engine. ACWR calculations now ran against a rolling 28-day window of actual load data. Readiness scoring pulled from real HRV baselines, not fixed numbers, and recalibrated as an athlete's personal baseline shifted over a training block. We replaced pre-written AI insights with a rules-based inference layer. Every insight shown in the platform now corresponded to a condition that was evaluated against live data. If Lena Vasquez's ACWR crossed 1.3 and her HRV dropped more than 15% from her 7-day baseline, the injury risk flag was triggered, not because it was hardcoded, but because those conditions were true. We implemented real role-based access control. A physio sees medical data, injury history, and RTP protocols. A sport scientist sees load analytics and benchmarks. A performance director sees the squad-level overview. A head coach sees readiness and today's session. The frontend already had role-switching built in, we gave it actual enforcement. We added observability throughout. Every data ingestion event was logged. Every calculation that produced an out-of-range result generated an alert. If a data source stopped sending, the system surfaced a staleness warning rather than silently displaying old numbers as current. ────────────────────────────────────────── Tech Stack React 19 + Vite, Tailwind CSS v3, Recharts, React Router v7, Node.js + Fastify, PostgreSQL + TimescaleDB, Redis, GPS/HRV/sleep data adapters (Catapult, Polar, Garmin), Google Forms/Typeform ingestion, Auth0, row-level security, Sentry, Datadog, Railway/Render, Vercel, Supabase Storage What Changed The morning workflow Marcus had been running across four tabs and a spreadsheet now ran in a single view that was populated automatically before he arrived at the training ground. The difference wasn't just convenience. It was confidence. When the dashboard flagged an athlete as high-risk, the coaching staff could interrogate why and trust the answer. When a return-to-play progression showed 80% completion, that number reflected actual criteria met against measured data, not a manually updated percentage. The platform was no longer a demo tool. It was a clinical decision-support system. For the squads using it, the shift was measurable: fewer reactive injury responses, more consistent load monitoring, and perhaps most importantly, a shared language between coaching staff, physios, and sport scientists built around the same data rather than competing interpretations of separate sources. ────────────────────────────────────────── The Part That Rarely Gets Said Most platforms built in this space start from the software side. Someone builds a data collection tool, adds a dashboard, and then tries to reverse-engineer what coaches actually care about. Athliq started from the other direction. A domain expert who understood the problem at a professional level built the frame first, and built it correctly. The pain points were real, the workflows were accurate, the terminology was precise. The engineering work didn't fix a bad idea. It made a good idea survivable. That distinction matters more than most technical case studies acknowledge. The hardest part of building a platform like this is not the infrastructure. It's knowing which questions to answer. That knowledge was already there. Our job was to make sure the system could keep answering them reliably, at scale, over time. ────────────────────────────────────────── Athliq is now in active deployment across two professional squads and one university performance program. The morning readiness dashboard processes real-time data from four integrated sources and serves role-scoped views to performance directors, sport scientists, physiotherapists, and athletes.
0
57
Cover image for Case Study: From Prototype to
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
0
68
Software Architect(2)
Muhammad Faisal's avatar
Muhammad Faisal
Karachi, Pakistan
Experienced Software Engineer Skilled in ErontEnd developmet
Experienced Software Engineer Skilled in ErontEnd developmet
Cover image for Tournament Management System
Tournament Management System
0
8
Cover image for Quranic Verse Slideshow with Translation
Quranic Verse Slideshow with Translation
0
12
Cover image for Python Snake Game – OOP-Based Game Development
Python Snake Game – OOP-Based Game Development
0
7
Placeholder project card media
View more →
Software Architect(2)
Abdul Wahab's avatar
Abdul Wahab
Karachi, Pakistan
Lead Full Stack Developer | AI/ML Engineer | Data Scientist
New to Contra
Lead Full Stack Developer | AI/ML Engineer | Data Scientist
Cover image for NewGenia: Clinical bioinformatics for clinicians
NewGenia: Clinical bioinformatics for clinicians
0
2
Cover image for AI Clinical Phenotype Mapping Platform Development
AI Clinical Phenotype Mapping Platform Development
0
0
Cover image for Case Studies
Case Studies
0
0
Cover image for I am a full stack developer and a team lead with the experie...
I am a full stack developer and a team lead with the experience in Web and Mobile Development
0
32
Software Architect(2)
Muhammad Sajid Lakha's avatar
Muhammad Sajid Lakha
Karachi, Pakistan
Full-Stack Dev · Next.js, Python, AI · 15yrs experience
Full-Stack Dev · Next.js, Python, AI · 15yrs experience
Cover image for Engineered an enterprise-grade multi-tenant B2B
Engineered an enterprise-grade multi-tenant B2B SaaS platform and React Native mobile application built specifically for luxury bespoke tailors and Savile Row ateliers. Key Features Delivered: Multi-Tenant Architecture: Database-per-tenant isolation (saas_tenantname) with custom domain mapping. Master Cutter Workflows: Role permissions for Master Cutters, Junior Cutters, and Bench Tailors with pattern approval transitions. Interactive Posture Canvas: HTML5 canvas tool enabling cutters to draw anatomical posture anomalies on client silhouettes with version control. Paper Pattern Room Archive: Physical pattern storage tracking for rack/bay/shelf locations across 8 garment types. Cross-Platform Mobile App: Included React Native (Expo) mobile apps for iOS and Android. Security & Automation: 100% prepared statements, CSRF protection, and automated Playwright E2E verification suite.
0
65
Cover image for QuickLeads Pro is a high-performance,
QuickLeads Pro is a high-performance, native Windows B2B lead generation, website deep-crawling, and automated email outreach desktop application built with Python and CustomTkinter (WinUI 11 dark cyberpunk layout). It parses local business directories, deep-crawls company websites using multi-threaded regex parsers, verifies business emails, extracts decision-maker phone numbers & addresses, and executes automated cold email outreach campaigns with ZERO third-party monthly API costs. 🔥 Core Features & Engine Capabilities: • Multi-Threaded Business Directory Scraper (scraper.py (http://scraper.py)): Scrapes company names, phone numbers, physical addresses, website links, and social media handles. • Deep Website Email & Phone Extractor: Crawls internal /contact, /about, and /team pages to parse hidden decision-maker emails using regex pattern matchers. • Embedded SQLite Leads Database (leads_db.py (http://db.py)): Persistent local database (leads_campaign.db) supporting 2,000+ lead records, filtering, and status tracking. • Automated Cold Email Outreach Engine (email_engine.py (http://engine.py)): Built-in SMTP email dispatcher with personalized HTML email templates, merge tags ({company_name}, {contact_person}), rate limiting, and follow-up campaign automation. • Data Exporter Engine (exporter.py (http://exporter.py)): 1-Click export to CSV, XLSX Excel workbooks, PDF summary reports, and JSON webhooks. • Executable Compilation (PyInstaller): Compiles into a single double-clickable, zero-dependency QuickLeads_Pro.exe standalone application. 🛠️ Technical Architecture & Stack: UI Framework: CustomTkinter (WinUI 11 dark cyberpunk aesthetic, Custom HSL gold/cyan themes) Core Language: Python 3.11 (Multi-threading, BeautifulSoup4, Requests, Regex) Database: SQLite3 with relational tables (leads, campaigns, email_logs) Packaging: PyInstaller with standalone hooks & custom icon assets
0
60
Cover image for Designed and developed an autonomous
Designed and developed an autonomous AI Voice Agent system for automated inbound customer support, appointment scheduling, and outbound sales calls. 🔥 Key Capabilities & Technical Features: Real-Time Ultra-Low Latency Speech Synthesis & Voice Recognition. AI Conversation Flow Engine with Dynamic Script Context & FAQs. Automated Calendar Booking Integration (Google Calendar / Calendly). Live Call Analytics Dashboard, Sentiment Analysis, and Call Transcripts. Multi-Channel CRM Sync & Automated Follow-Up Dispatches. 🛠️ Tech Stack: Python, WebSockets, OpenAI / Anthropic APIs, ElevenLabs Speech AI, FastAPI, React, Node.js.
0
63
Cover image for AI Voice Agent Pro —
AI Voice Agent Pro — Autonomous 24/7 B2B AI Voice Telephony & Appointment Booking SaaS platform built with Python FastAPI, SQLite CRM, PBKDF2 Password Hashing, Twilio TwiML, OpenAI, and WebSockets. Features 5 interactive dashboard views (Agent Studio, Live Call Simulator, Lead CRM, Telephony Settings, Dashboard), intent classification, automated SMS confirmations, and 100% verified unit test pass rate (6/6).
0
84
Software Architect(1)
Huzaifah Punjani's avatar
Huzaifah Punjani
Karachi, Pakistan
AI, SaaS & Full-Stack Product Development Studio
New to Contra
AI, SaaS & Full-Stack Product Development Studio
Cover image for Robo Call Pakistan — AI
Robo Call Pakistan — AI Voice Automation SaaS Robo Call Pakistan was developed to solve a common problem faced by e-commerce and service-based businesses: manual customer follow-ups, fake orders, delayed confirmations, and poor response rates. The platform allows businesses to automate outbound voice calls and collect customer responses through IVR inputs. For example, customers can press 1 to confirm an order, press 2 to cancel, or press 3 to request a callback. The system supports campaign management, call logs, customer response tracking, retry logic, reporting dashboards, and integrations with e-commerce platforms such as Shopify and WooCommerce. Key Features AI-powered voice automation Automated order confirmation calls Feedback and reminder calls IVR-based response collection DTMF input tracking Call status analytics Campaign dashboard Retry management Shopify and WooCommerce integration API-based communication workflows Problem Solved Businesses were spending significant time and resources on manual calling and customer follow-ups. Robo Call Pakistan helped automate this process, reduce manual workload, improve response tracking, and create a scalable communication workflow. My Role Founder, product strategist, business lead, and platform owner. Led product direction, use-case planning, feature design, business model, client requirements, and platform growth strategy.
0
44
Cover image for We recently worked on a
We recently worked on a branded Android softphone/dialer concept for business calling. Features included: SIP login incoming/outgoing calls call history dial pad contacts agent calling interface business communication flow Android apps are still powerful when they solve real operational problems.
0
28
Cover image for Built a Shopify app concept/integration
Built a Shopify app concept/integration for Robo SMS Pakistan to help merchants automate SMS alerts, campaigns, OTPs, and order-related customer communication. Highlights: Shopify order event triggers SMS automation workflows Customer notifications Transactional SMS Campaign messaging API key-based integration Merchant-facing settings Usage-based communication model Skills & Tools: Shopify Development, Shopify API, SMS Automation, Laravel, PHP, REST API, Webhooks, E-commerce Messaging, API Integration
0
31
Cover image for RoboConnect — Cloud Business Calling & Helpline Platform
RoboConnect — Cloud Business Calling & Helpline Platform
0
2
Software Architect(1)
Ahtisham Hasan Khan's avatar
Ahtisham Hasan Khan
Karachi, Pakistan
Expert React Native & iOS Developer for Your Projects
Expert React Native & iOS Developer for Your Projects
Cover image for Problem: Users need a fast,
Problem: Users need a fast, reliable, and secure way to digitize physical documents and extract text without relying on privacy-invasive cloud processing. Solution: I developed ScanIt, a native iOS utility built with SwiftUI and VisionKit. The app provides a professional scanning experience, focusing on high-speed edge detection, automatic perspective correction, and on-device OCR. Key Engineering Highlights: VisionKit Integration: Leveraged Apple’s VNDocumentCameraViewController for seamless, native document capturing with automatic shutter and real-time guidance. On-Device OCR: Implemented the Vision Framework for high-accuracy Optical Character Recognition (OCR), allowing users to search, copy, and share text directly from images without an internet connection. Advanced PDF Processing: Built custom logic for PDF generation, compression, and digital signature integration to ensure documents are office-ready. SwiftUI Performance: Optimized the UI for speed and responsiveness, ensuring large multi-page scans remain fluid and memory-efficient. Privacy-First: Designed the architecture to keep all document processing local to the device, prioritizing user security.
0
22
Cover image for Analytics
Analytics
0
7
Cover image for TradersGPT
TradersGPT
0
9
Cover image for I engineered Just Invoice, a
I engineered Just Invoice, a high-performance native iOS application. I focused on a modular architecture to support deep localization, including a full Spanish version, and integrated a robust analytics dashboard for real-time financial insights.
0
28
Software Architect(3)
Suneel Kumar Khatri's avatar
Suneel Kumar Khatri
Karachi, Pakistan
Full Stack Dev | React · Next.js · Node.js · TypeScript
New to Contra
Full Stack Dev | React · Next.js · Node.js · TypeScript
Cover image for Real-Money Gaming Platform — Backend
Real-Money Gaming Platform — Backend at Scale Engineered the complete backend microservices architecture for Pryze, a real-money competitive gaming platform with live leaderboards, real-time gameplay, and multi-provider payment processing. THE CHALLENGE Build a backend that handles thousands of concurrent players, real-time match updates, secure payment flows, and live leaderboard scoring — all with near-zero downtime. WHAT I BUILT Microservices architecture on Node.js handling 15K+ daily requests Real-time leaderboard system processing 30K+ score updates daily via RabbitMQ + Redis Pub/Sub Redis caching + MongoDB query optimization — 45% faster data retrieval (280ms → 154ms) Payment integrations: EasyPaisa, SimPaisa, PayFast with webhook handling and retry logic WebSocket-based messaging for 10K+ concurrent users AWS infrastructure: EC2, S3, X-Ray, CloudWatch Comprehensive Swagger API docs — cut third-party integration time by 50% RESULTS → 15K+ daily active users supported at 99.9% uptime → 45% faster data retrieval after caching optimization → 35% increase in daily user engagement → 30K+ real-time leaderboard updates processed daily
0
50
Cover image for Bhoomi Restaurant Singapore — Full
Bhoomi Restaurant Singapore — Full Website Build Designed and built a complete restaurant website for Bhoomi by Chef Milind Sovani, an Indian fine dining restaurant in Singapore. WHAT I BUILT Multi-page responsive website with rich animations and transitions Landing page with image carousel and promotional banners Comprehensive menu pages with categorized dishes (meat, vegan, gluten-free, drinks) Chef profile, restaurant story, and ambience gallery Blog and media coverage sections Online ordering and table booking integration E-commerce shop page for merchandise/products THE IMPACT → Fully responsive across all devices → Fast load times optimized for SEO → Complete brand representation online → Integrated ordering and booking workflows
0
22
Cover image for AI Sales Platform — Real-Time
AI Sales Platform — Real-Time UI with 35% Latency Cut Built the frontend for Outbound Labs, an AI-powered platform where autonomous SDR agents prospect, qualify leads, and book meetings without human intervention. THE CHALLENGE Render live AI-generated conversations in real-time where UI latency directly impacts product experience and customer trust. Every millisecond of delay makes the AI feel sluggish. WHAT I BUILT Visual workflow builder with drag-and-drop for designing custom AI conversation flows — no code required Real-time UI components rendering live AI-generated responses Type-safe component library using TypeScript + React for fast MVP iterations Optimized state management with Redux + custom hooks — 25% fewer unnecessary re-renders Code splitting + lazy loading for performance optimization RESULTS → 28% improvement in page load performance → 35% reduction in UI latency for AI response rendering → +20 Lighthouse accessibility score improvement → 25% fewer unnecessary component re-renders
0
29
Cover image for Enterprise Tax SaaS — 5,000+
Enterprise Tax SaaS — 5,000+ Offices, 50K+ Returns Built and maintained a full-stack tax filing solution serving 5,000+ registered tax offices processing 50,000+ annual returns, with scalable Node.js backend and React frontend. THE CHALLENGE Create a reliable, accurate tax calculation engine compliant with FBR regulations, serving thousands of tax professionals during high-pressure filing seasons with zero tolerance for downtime. WHAT I BUILT Complex tax calculation engine implementing FBR regulations across multiple return types (99.7% accuracy) Comprehensive React dashboard with automated computation workflows, client management, and real-time filing tracking Optimized API performance — response times reduced from 450ms to 315ms (30% improvement) Led code reviews for 3-person development team Collaborated with DevOps on deployment workflows RESULTS → 99.8% platform uptime including peak tax season → 40% reduction in processing time via automated workflows → 30% faster API responses → 18% fewer production bugs during critical filing periods
0
45
Software Architect(1)