A cinema-style discovery application connecting browsing, profiles, recommendation experiments, and shared-viewing workflows.
The idea
Movie discovery, personal profiles, and shared viewing need to feel like one coherent product.
My work
Built the discovery interface and connected profile, recommendation, playback-progress, and watch-party workflows across the frontend and API.
React
FastAPI
MongoDB
Redis
Python
HLS
Features
Browse films by genre and language
Keep profile-specific lists and viewing history
Explore shared-viewing and recommendation workflows
Architecture
React application with profile context and routed discovery screens.
FastAPI services with MongoDB persistence, Redis/Celery work paths, and recommendation modules.
Separate streaming, catalogue, and watch-party integrations.
Product workflows
4 connected areas
Discovery, profiles, recommendations, and shared viewing are represented in source. Implementation scope; no user-adoption count.
Evidence, validation & limits+
Validation
Current source contains the routed discovery, profile, recommendation, and shared-viewing interfaces.
The recorded interface capture is preserved whole. Current local catalogue loading did not complete during review; no live playback, payment, or recommendation-quality check was performed.
No user count, revenue result, streaming capacity, or recommender accuracy is inferred from the interface.
Limits
Backend/provider availability determines catalogue, recommendation, and playback behavior.
A watch-party interface is not a measured concurrency result.
Source was not anonymously accessible under the former portfolio URL on 14 October 2026.
Explore kernel source, hardware constraints, illustrative compiler passes, and roofline estimates alongside separate Triton kernel experiments.
The idea
Kernel code and hardware constraints are difficult to reason about when memory movement, tiling, and generated representations remain disconnected.
My work
Built an interactive source-and-inspector workbench with kernel presets, hardware choices, parameter controls, and explicit separation between static estimates and measured GPU behavior.
Python
PyTorch
Triton
TypeScript
React
CUDA
Features
Inspect and edit kernel presets
Explore hardware and tile parameter choices
Compare illustrative IR and roofline estimates
Architecture
Next.js and React workbench with an editable source pane.
TypeScript static analyzer derives illustrative compiler representations and hardware estimates.
Separate Python/Triton kernel implementations and hardware-specific correctness/benchmark paths.
Kernel presets
4
Four authored frontend source presets for inspection. This is workbench scope, not a GPU benchmark.
Hardware profiles
4
Static hardware specifications in the analyzer. Selecting a device does not run code on that device.
Evidence, validation & limits+
Validation
The current frontend source has four kernel presets and four hardware specification profiles. These are implementation counts, not measured hardware runs.
The local browser workbench renders source, parameter controls, and analysis output. No GPU benchmark was executed for the portfolio.
Historical T4 speedup tables require independently inspectable hardware receipts; those values are not used as portfolio performance claims.
Limits
The browser analyzer does not invoke a real Triton GPU compiler.
Illustrative IR, occupancy, and roofline output do not prove device execution or speedup.
Kernel correctness and performance depend on hardware, shapes, layouts, and numerical tolerances.
A code-repair workbench that keeps original source, proposed patches, independent checks, and observed outcomes inspectable together.
The idea
A plausible generated patch needs an inspectable source context, execution history, and independent checks before a reviewer can assess it.
My work
Built durable, inspectable repair workflows with fenced workers and independent verification. Local release acceptance passed 428 backend checks; model repair quality is evaluated separately.
Next.js
FastAPI
PostgreSQL
Python
Docker
OIDC
Features
Inspect original source and proposed patches
Review independent checks and saved evidence
Resume durable authenticated investigations
Architecture
Next.js evidence viewer and authenticated workbench.
FastAPI with PostgreSQL request receipts, ordered steps, tenant roles, and worker leases.
Local inference, disposable Docker checks, and digest-addressed artifacts.
Backend checks passed
428
14 October 2026 local release acceptance: 6 explicit opt-in skips, zero failures or errors. Software validation is separate from repair quality.
Browser journeys passed
24
Eight evidence-viewer, eleven fault-fixture, four real-OIDC and one separate real-model development journey. These are different test scopes, not 24 repair successes.
Evidence, validation & limits+
Validation
14 October 2026 local acceptance collected 434 backend tests: 428 passed, 6 explicit opt-in skips, zero failures or errors. Saved receipts: evidence/docs008/checks/backend-summary.json and fullstack-acceptance.json.
Twenty-four browser journeys passed across separate scopes: 8 evidence-viewer, 11 fault-fixture, 4 real-OIDC, and 1 exposed development-case model journey. This is software workflow coverage, not a repair-success count.
A saved Django development repair was reproduced against its registered checks. Fresh repair validation verified 0/10 attempts across five qualified cases; the development success is separate.
The completed 12 October 2026 local control-plane repeat processed 435,270 requests over approximately 42 minutes with zero unexpected errors. Its ten-client, 30-minute soak recorded acknowledgement p95 275.19 ms and read p95 16.79 ms. It used real HTTP/PostgreSQL and fixture identity/tasks, without inference or OIDC throughput. Saved receipt: evidence/build004/capacity-summary-final.json; earlier failures remain preserved.
The source repository is private. These notes summarize locally inspected receipts; source files and downloadable receipts have not been published here.
Limits
None of the ten fresh repair attempts across five qualified cases passed the registered verification checks. This measures model repair quality, not backend reliability. The single reproduced development repair was a separate, already-exposed case; broader repair usefulness remains unproven.
Recorded inspection does not run a new investigation or change a visitor's repository.
Local control-plane capacity does not establish production scale or inference throughput.
An approval-gated support-action system with durable execution, explicit authority, recipient receipts, and recovery after worker failure.
The idea
An action can outlive an HTTP response or a worker. Retrying without recipient evidence can repeat the external effect.
My work
Completed 128 synthetic actions with 128 recipient receipts in a bounded hosted run by combining approval-bound actions, fenced workers, and receipt reconciliation.
Go
PostgreSQL
Python
JavaScript
Docker
Features
Propose and approve exact action hashes
Inspect execution state and audit events
Reconcile recipient receipts after failure
Architecture
Go API, PostgreSQL approval/action storage, and a separate Go worker.
Browser workspace for proposals, approval, saved state, and audit events.
Authenticated simulated order API with SQLite receipts and an experimental typed model-draft path.
Completed synthetic actions
128 / 128
13 October 2026 hosted bounded workload, with 128 recipient effect receipts. Four callers, two workers; not saturation or a production SLA.
Evidence, validation & limits+
Validation
13 October 2026 hosted CI verified a dated engineering baseline, including recovery, race checks, browser workflows, and restore drills.
A bounded synthetic hosted workload completed 128 actions with 128 effect receipts; it is not a production SLA or saturation result.
The frozen model evaluation stopped at 62/80 cases and already failed its declared utility and safety gates.
Limits
AI quality qualification remains open. Engineering checks do not qualify autonomous decisions.
The simulated recipient supplies explicit idempotency and receipt guarantees that arbitrary external APIs may lack.
No customer deployment or API cost saving is claimed.
A transaction inspection workbench combining prior-only features, versioned model artifacts, tenant-scoped access, and exact saved-result retries.
The idea
Evaluation and serving can disagree when features include future information or retries recalculate accepted transactions.
My work
Shared prior-only feature construction between offline and serving paths, then added atomic SQLite replay and role-controlled inspection.
FastAPI
SQLite
scikit-learn
Python
JavaScript
Features
Inspect original saved scoring results
Retry accepted transactions without re-scoring
Use tenant-scoped reader, writer, and admin roles
Architecture
One feature module for offline preparation and serving.
Versioned scikit-learn artifact, runtime manifests, and export/reload parity checks.
Tenant-scoped FastAPI, SQLite replay history, and browser workbench.
Shared scoring features
8
Four current-input and four prior-history features use the same offline and serving module. Implementation fact, not a quality score.
Local scoring p95
16.77 ms
12 October 2026 client-inclusive measurement: 4,800 generated unlabeled scores over 120 seconds, four clients at 10 requests/s each, zero failures. Not saturation or production latency.
Evidence, validation & limits+
Validation
The 10 October 2026 historical study used a chronological 100,000-row prefix with separate fit, calibration, selection, and historical final partitions.
Historical fixed-threshold precision was 9.23% and recall was 41.28%; most alerts were false and most fraud was missed.
The dated hosted engineering baseline at 676a4795ba04a7bb2acf2bf573826a6e9d77311a, run 38409317955, passed 404 Python tests with zero failures, errors or skips. CI uses synthetic model fixtures and separately exercises parity, roles, retries, browser behavior, restart recovery, and same-host restore.
A separate 12 October 2026 local workload completed 4,800 generated unlabeled scores over 120 seconds, with four clients paced at 10 requests/s each, zero failures and client-inclusive p95 16.77 ms. This is one selected-model development-host measurement, not fraud accuracy, saturation, a speedup, or a production SLA. Saved receipt: reports/operating-2026-10-12/selected-model-001/report.json; documented in docs/resume-contract.md.
The repository was not publicly accessible on 14 October 2026. These notes summarize locally inspected source and receipts; downloadable receipts are not attached.
Limits
Historical full-source exposure cannot be ruled out. The old final partition is development-only for future work.
No independently unseen production fraud-prevention result is claimed.
Raw transactions and model weights remain unpublished; redistribution permission is unreviewed.
Turns a supplier notice into record-backed exposure, a revision-bound human decision, and durable inventory or task actions in a sandbox.
The idea
Supplier notices need traceable affected lots and approvals that remain valid only for the reviewed record revision.
My work
Connected lot tracing, revision-bound approval, durable sandbox receipts, and explicit pending inference states.
React
FastAPI
PostgreSQL
Python
SQLite
Features
Trace notices to affected demonstration lots
Approve the exact reviewed revision
Recover sandbox actions through durable receipts
Architecture
React case register and review interface.
FastAPI with SQLite development storage and a PostgreSQL deployment adapter.
Bounded inference worker and sandbox inventory/task actions.
Authored fault scenarios
40 / 40
Stored local synthetic-fixture checks: stale approval, duplicate intent, fencing, lost acknowledgement, and recovery. Live model qualification remains open.
Evidence, validation & limits+
Validation
Stored local evidence records 40/40 authored fault scenarios covering stale approval, duplicate intent, fencing, lost acknowledgement, and recovery.
Real HTTP and PostgreSQL adapter checks exercise authority, revision, persistence, and receipts.
Limits
Demonstration notices, records, and policies are authored synthetic fixtures.
Live model quality, AMD workload, and public deployment are not qualified.
A sandbox hold is a software state change. No factory savings or physical containment result is claimed.
A railway-operations prototype exploring agent workflows, dispatch review, and an operations interface.
The idea
Railway dispatch suggestions need an operations view where a person can inspect disruptions and deliberately approve or override a recommendation.
My work
The inspected implementation connects dispatch review, explicit approval or override, disruption records, and event staging. This describes the source scope, without claiming operation on a live railway.
Python
FastAPI
React
Features
Review dispatch recommendations, approve a proposal, or record a manual override.
Inspect train disruptions and their details through dedicated operations routes.
Stage events in a transactional outbox and expose an audit workflow.
Architecture
React operations interface backed by versioned FastAPI routes for trains, disruptions, recommendations, and audit.
Separate prediction and stream-service modules; a SQLite-backed outbox stages events before relay.
Evidence, validation & limits+
Validation
Local source review covered recommendation approval/override routes, disruption routes, and TransactionalOutbox. No dispatch, prediction, or load benchmark was rerun.
Limits
Operational safety, live data freshness, and real railway performance are not established by this prototype.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
An earlier systems experiment exploring vector compute and service interfaces. Detailed validation has not been attached.
The idea
Explore how vector-compute work can be exposed through service interfaces; the archived version needs matching source before its implementation can be described precisely.
My work
This entry preserves an earlier systems experiment. Version-specific implementation ownership and working behavior need the matching source before a more detailed personal contribution can be stated.
Go
gRPC
Features
Earlier project intent: explore vector-compute work and service interfaces.
The archived record identifies Go and gRPC; its exact API and worker behavior remain unverified.
Architecture
The historical record describes a Go/gRPC systems experiment, without an inspectable service diagram or source link.
A local folder named HELIOS contains a different Java workflow engine; that implementation is not used as evidence for this archived version.
Evidence, validation & limits+
Validation
No source matching this Go/gRPC description, reproduced benchmark, or current public repository was established in this review.
Limits
The Java workflow engine and the archived vector-compute experiment must not share implementation or performance claims merely because their names match.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
An earlier code-generation and fine-tuning experiment, distinct from the current CodeSage source workspace. Model quality is not established here.
The idea
Investigate whether a compact code model can be adapted for Python bug-fix completion while keeping data preparation, memory constraints, and evaluation explicit.
My work
The earlier experiment includes dataset preparation, memory-conscious adapter configuration, checkpoint recovery, and evaluation tooling. These are inspected implementation paths, not a newly verified model improvement.
Python
PyTorch
Features
Prepare filtered Python bug-fix instruction/response examples from CommitPack.
Configure a QLoRA adapter training path for Qwen2.5-Coder-1.5B-Instruct.
Resume saved checkpoints and compare baseline and adapter evaluation outputs.
Architecture
Python dataset preparation, Unsloth/Transformers fine-tuning, and separate CodeBLEU, HumanEval, and repository-context evaluation scripts.
Training configuration uses short sequences, gradient accumulation, epoch checkpoints, and provenance helpers; the current source workspace is a separate portfolio entry.
Evidence, validation & limits+
Validation
Local review inspected training/finetune.py and training/MODEL_CARD.md. Historical GPU and score values were not reproduced or promoted into portfolio metrics.
Limits
No new GPU training, held-out evaluation, contamination audit, or verified code-repair result was produced for this review.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
An interpretability interface for exploring model activations and experimental agent-analysis workflows.
The idea
Model outputs alone hide what changed inside a run. Researchers need to inspect activations and test interventions without mistaking correlation for causation.
My work
The inspected source joins run inspection with sparse-feature analysis and intervention tooling. It explicitly labels correlation-based co-activation separately from causal patching.
Python
PyTorch
React
Features
Inspect model runs, per-step activations, sparse features, and saved experiment findings.
Explore activation patching, patch matrices, and feature steering through separate API paths.
Plot sparse-feature timelines and exploratory co-activation relationships.
Architecture
React experiment interface with FastAPI routers for runs, experiments, steering, and probe training.
PyTorch model hooks and SAE decomposition feed saved step artifacts; patching and steering modules perform distinct interventions.
Evidence, validation & limits+
Validation
Local review covered run and steering routes plus SAE, patching, and steering modules. No model execution or causal finding was independently reproduced.
Limits
Feature descriptions, drift estimates, and steering outcomes require model-specific experiments; an interface or graph is not proof of interpretability accuracy.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
A legal-research retrieval prototype exploring dense, lexical, and graph-based context.
The idea
Explore legal-research context retrieval across semantic matches, lexical matches, and graph relationships; the matching historical source is still needed to verify those paths.
My work
This preserves the earlier retrieval idea and declared stack. Exact implementation scope and personal task attribution require the matching legal-research source.
Python
PostgreSQL
Neo4j
Features
Archived concept: retrieve legal-research context through dense, lexical, and graph-based approaches.
The retained stack names PostgreSQL and Neo4j; working retrieval behavior has not been verified for this version.
Architecture
The legal-research version is described as Python retrieval over relational and graph stores; its actual retrieval and ranking code is unavailable for review.
Local NeuralVault folders instead contain database-intelligence demos. Their SQL and fraud modules are not evidence for the legal-research version.
Evidence, validation & limits+
Validation
No matching legal-research implementation, retrieval evaluation, or citation-quality measurement was established in this review.
Limits
No legal-answer accuracy, corpus coverage, or retrieval improvement is claimed. The similarly named database demo is a separate version.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
An OpenEnv support-ticket environment for agent-training experiments and task grading.
The idea
Agent-training experiments need repeatable support-ticket tasks with explicit actions, state transitions, and grading rules rather than a free-form chat demo.
My work
The source implements ticket-state transitions, task-specific rewards, reproducible episode selection, and an interface for agent-training experiments.
Python
FastAPI
OpenEnv
Features
Reset reproducible support-ticket episodes with an optional pinned ticket and RNG seed.
Apply routing, urgency, response, escalation, and closure actions to a ticket state.
Grade routing, triage, and resolution tasks and inspect terminal rewards.
Architecture
Python environment exposes reset, step, and state operations with typed ticket actions, observations, and rewards.
Bundled ticket/task definitions are separate from graders; a FastAPI server and UI expose the environment, alongside training and evaluation scripts.
Evidence, validation & limits+
Validation
Local review inspected env/environment.py, env/graders.py, task definitions, and the test-file structure. No training or evaluation was rerun.
Limits
The response grader can call a model when configured and otherwise uses heuristics. A heuristic reward is not a measured customer-service outcome.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
A safety-assistance concept exploring location sharing, voice analysis, and emergency-contact workflows.
The idea
Bring SOS session state, guardian location sharing, and route context into one prototype, with separate interfaces for assistance and threat-analysis experiments.
My work
The implementation combines SOS lifecycle routes, location sharing, route-inspection logic, and a separate ML API. This is prototype scope; emergency delivery and detection quality have not been demonstrated here.
React Native
React
Node.js
Express
FastAPI
MongoDB
Python
Features
Create, track, update, and resolve an SOS session with a shareable location link.
Explore incident-based route suggestions and a guardian-facing dashboard.
Expose separate audio-distress, text-threat, and assistance-chat endpoints.
Architecture
React Native mobile client and React guardian dashboard connect to an Express API and Socket.IO event paths.
MongoDB stores application records; separate Firebase/Redis/Twilio integrations and a Python FastAPI ML service handle specialized workflows.
Evidence, validation & limits+
Validation
Source reviewed on 15 October 2026. The application and its external integrations were not executed in this review.
Source includes explicit fallback route behavior when Google Maps is unavailable; API presence does not establish distress-detection accuracy.
Limits
No real SOS, SMS, location broadcast, emergency dispatch, or safety-effectiveness test was performed for the portfolio.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
A hackathon finance-workbench prototype exploring spend inspection, forecasting, and reconciliation.
The idea
Explore how spend review, variance explanations, and month-end checks can be organized as separate finance workflows instead of one unstructured assistant response.
My work
The source defines finance-agent workflows, demo connectors, and transaction-inspection logic. Individual task ownership is not independently documented; no live accounting automation is established.
Python
FastAPI
CrewAI
Features
Define sequential spend classification and executive-narrative tasks.
Build forecast/variance and month-end reconciliation/compliance workflow definitions.
Inspect sample transaction scoring and GST input-tax-credit reconciliation paths.
Architecture
Python CrewAI orchestrator composes specialist agents and typed tasks behind a FastAPI-oriented project structure.
Separate integration clients and scoring modules include demo GST responses and a heuristic anomaly scorer.
Evidence, validation & limits+
Validation
Source reviewed on 15 October 2026. The application and its external integrations were not executed in this review.
The inspected orchestrator imports close_accelerator and compliance_guardian modules, while the reviewed tree contains close_and_compliance.py. The workflow is not represented as a verified runnable system.
The anomaly score includes hand-written rules and random noise; it is not evidence of a trained detector's quality.
Limits
Compliance outputs and GST demo data are prototype behavior, without live filing, ledger reconciliation acceptance, or financial accuracy validation.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
A learning-path prototype comparing resume and role requirements and ordering prerequisite skills.
The idea
A list of missing skills does not tell a learner what to study first. Build a pathway that expands prerequisites and explains its course order.
My work
The source connects profile extraction to a prerequisite-aware pathway engine and an explainable results screen. The README names a team; an exact personal task split has not been independently established.
FastAPI
React
Python
Gemini
Features
Compare resume-derived skills with a target role and expand missing prerequisites using DFS.
Order skills with Kahn's topological sort so prerequisites precede dependent courses.
Pack courses into weekly phases and show the reasoning behind added skills and ordering.
Architecture
React upload/results flow calls FastAPI analysis and pathway routes.
Gemini extraction produces a profile; a separate Python catalog and deterministic pathway engine compute gaps, prerequisite order, and phase allocation.
Evidence, validation & limits+
Validation
Source reviewed on 15 October 2026. The application and its external integrations were not executed in this review.
Inspected compute_skill_gap, prerequisite resolution, topological_sort, pack_into_phases, and profile extraction. The README's speed claim was not reproduced.
Limits
The authored catalog bounds pathway coverage. Extraction quality and learning outcomes have not been measured here.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
A clinical-note concept exploring bilingual transcription and structured notes.
The idea
Explore converting a bilingual consultation transcript into structured note fields while keeping transcription, entity extraction, and record mapping distinct.
My work
The source joins an audio-session pipeline to structured-note mapping. The README identifies a team project; personal implementation boundaries have not been independently established.
Flutter
Dart
FastAPI
Python
Whisper
PostgreSQL
Features
Accept consultation audio chunks and send transcription/status updates through a session workflow.
Explore Hindi/English transcription, speaker separation, and clinical-entity extraction.
Map extracted entities into patient, encounter, condition, observation, and medication-oriented FHIR structures.
Architecture
Flutter client configuration accompanies a FastAPI backend with session, transcription, and notes routes.
Session orchestration calls separate ASR, NLP, and FHIR-mapping modules, then saves structured notes through database helpers.
Evidence, validation & limits+
Validation
Source reviewed on 15 October 2026. The application and its external integrations were not executed in this review.
ASR, session orchestration, and FHIR mapping were read. No clinical audio, custom model training, FHIR conformance test, or ABDM integration was exercised.
Limits
Historical latency and medical-speech training claims are not adopted. Generated notes require clinical review; no clinical accuracy is established.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
An interview-practice prototype with generated questions, transcription, and feedback experiments.
The idea
Connect interview setup, adaptive questions, recorded answers, and reviewable feedback in one session rather than showing a disconnected question generator.
My work
The implementation integrates a multimodal interview-session pipeline and report presentation. The README names a team; the personal task split is not independently established.
FastAPI
React
Python
Features
Coordinate interview questions, audio-answer processing, and video-frame analysis within a session.
Aggregate answer and speech signals into a five-dimension score report.
Define optional avatar speech through separate text-to-speech and streaming service adapters.
Architecture
React interview screens connect to FastAPI session routes and an orchestration layer for ASR, CV, question generation, and reporting.
Scoring uses explicit weighted formulas; explanatory strings are constructed from rules, with separate external avatar-service calls.
Evidence, validation & limits+
Validation
Source reviewed on 15 October 2026. The application and its external integrations were not executed in this review.
Reviewed the orchestrator, scorer, and avatar service. The scorer builds SHAP-style text from rules; the inspected explanation path does not calculate SHAP values.
Limits
No hiring validity, demographic fairness, transcription accuracy, or production readiness was verified. A removed-field list is not a bias audit.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
Signal-analysis and machine-learning experiments for detecting GNSS spoofing patterns.
The idea
Explore whether signal-derived features and learned models can distinguish GNSS spoofing patterns; dataset and evaluation evidence are needed before claiming detection performance.
My work
The source implements signal-feature preparation, dataset construction, weighted model fusion, and threshold search. The README names a team; the exact personal task split has not been independently established.
Python
PyTorch
XGBoost
Features
Extract 18 configured signal-quality, geometry, and cross-satellite features from epoch-grouped CSV observations.
Combine normalized LSTM reconstruction error with XGBoost probabilities in a weighted decision.
Tune a decision threshold on validation scores and prepare separate tabular and sequence datasets.
Architecture
Python feature extraction normalizes CSV column names, groups satellite observations by epoch, and writes feature records.
PyTorch sequence datasets and XGBoost inputs share a training-fitted scaler; the ensemble combines both outputs. Missing feature data triggers synthetic-data generation.
Evidence, validation & limits+
Validation
Source reviewed on 15 October 2026. The application and its external integrations were not executed in this review.
The actual public repository name ends with a dot: gnss-antispoofing. Feature extraction, ensemble prediction, and dataset code were inspected. The 18-feature count is implementation scope; README recall, false-alarm, and latency targets were not reproduced.
Limits
Some signal features use simplified formulas or defaults, and absent input can produce synthetic data. The code's random stratified split does not establish held-out receiver/scenario performance.
No live receiver integration, independently verified spoofing detection rate, or GNSS protection claim is made.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
A conversational exploration prototype for ARGO ocean-float records and visualizations.
The idea
Ocean-profile records are awkward to explore through chat alone. Pair filtered retrieval with maps and depth plots that expose the underlying profile context.
My work
The implementation connects question routing, filtered profile views, retrieval context, and scientific-style visualizations. Personal task attribution is not established by the README's placeholder team table.
Python
Streamlit
FAISS
Plotly
Features
Route questions by intent and extract region/month filters before visualizing ocean profiles.
Retrieve profile summaries with FAISS or a cosine-similarity fallback for a prompted answer.
Plot float maps, temperature/salinity depth profiles, time series, and regional comparisons.
Architecture
Streamlit coordinates a Python query router, retrieval pipeline, and Plotly visualization module.
A Parquet-backed profile dataset and summary index feed filters and semantic retrieval; a configured Groq service generates answers.
Evidence, validation & limits+
Validation
Source reviewed on 15 October 2026. The application and its external integrations were not executed in this review.
The README explicitly lists synthetic Indian Ocean profiles; routing, retrieval, and plotting functions were inspected. No answer-quality or scientific-data validation was rerun.
Limits
Charts over synthetic profiles do not establish oceanographic findings or coverage of the live ARGO archive.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
A container integration exercise connecting API, database, object storage, and reverse proxy.
The idea
Practice the real integration boundary between browser uploads, API validation, metadata persistence, object storage, and container routing.
My work
The source implements the integration boundary between browser upload, API validation, object storage, metadata persistence, and container routing.
Node.js
MongoDB
MinIO
Docker
Features
Upload multipart files to MinIO and return a retrievable object path.
Stream a stored object back with its content type and length.
Create and list metadata records through a separate API route.
Architecture
React frontend and Express API run alongside MongoDB, MinIO, and an Nginx reverse proxy in Docker Compose.
File bytes go to object storage while metadata uses a MongoDB model; upload middleware applies a 50 MiB file-size limit.
Evidence, validation & limits+
Validation
Source reviewed on 15 October 2026. The application and its external integrations were not executed in this review.
Inspected upload/download, metadata routes, and Compose service definitions. The 50 MiB upload setting is a code limit, not a measured throughput result.
Limits
Container startup, object round-trip behavior, access controls, and failure recovery were not rerun in this review.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
A finance-analytics prototype exploring spend data, anomaly inspection, and forecasting.
The idea
Make sample finance data inspectable through transaction, anomaly, forecasting, and question-answering endpoints while keeping demo inputs visible.
My work
The source assembles a finance-analytics API around sample data, anomaly inspection, forecasting, and chat. The README names Gaurav and Mohit; exact personal implementation scope is not independently established.
Python
FastAPI
scikit-learn
Features
List generated sample transactions and inspect Isolation Forest anomaly flags.
Request a cash-flow forecast through a model/statistical-fallback interface.
Expose a finance-question chat endpoint with resettable conversation state.
Architecture
FastAPI routes connect transaction ingestion, a scikit-learn anomaly detector, a cash-flow forecaster, and a separate copilot module.
The inspected API initializes mock transactions and a generated cash-flow series; the forecaster falls back to exponential smoothing without a trained neural model.
Evidence, validation & limits+
Validation
Source reviewed on 15 October 2026. The application and its external integrations were not executed in this review.
Mock transaction generation, startup initialization, feature extraction, and forecasting fallback were inspected. No live Zaggle connection or predictive-quality result was reproduced.
Limits
Demo anomaly flags and forecasts do not establish fraud detection, financial savings, or compliance automation.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
A research-assistance prototype exploring Amazon Nova, document context, and cited reports.
The idea
A research answer should retain its source context. Explore query planning, source collection, ranking, and report assembly as inspectable stages.
My work
The README attributes team lead, backend, Nova Act integration, and orchestration to Gaurav; this is a historical self-described role, not an independently audited commit attribution.
Python
Amazon Nova
AWS Bedrock
FAISS
Features
Decompose a research query, gather web/document context, and synthesize a cited report.
Rank source embeddings with FAISS or an in-memory cosine-similarity fallback.
Keep report formatting and optional voice input/output in separate modules.
Architecture
A Python orchestrator coordinates Bedrock, web search, document reading, synthesis, embeddings, and output formatting.
Search has a Nova Act path plus a requests/BeautifulSoup fallback; configured services and a no-key demo are distinct execution modes.
Evidence, validation & limits+
Validation
Source reviewed on 15 October 2026. The application and its external integrations were not executed in this review.
Reviewed orchestration, embedding ranking, and both web-search paths. No Nova/Bedrock call, citation audit, or end-to-end research run was performed.
Limits
A formatted report and confidence field do not establish factual accuracy, source completeness, or research quality.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
Traffic-control experiments using vehicle detection, forecasting, and simulation.
The idea
Explore a city-operations interface that connects junction state, traffic history, forecast output, and signal-control experiments.
My work
The README describes Gaurav as team lead/AI-ML engineer and Mohit as data/full-stack engineer. Those are historical self-described roles; the exact personal code split has not been audited.
Python
PyTorch
SUMO
React
Features
Inspect junction state, traffic history, forecast routes, and a city dashboard.
Define a signal-control loop with an optional learned-policy path and heuristic fallback.
Expose forecast output from optional LSTM weights or moving-average/trend fallback logic.
Architecture
React operations views connect to a FastAPI service with database models, traffic routes, and WebSocket-oriented updates.
Separate signal-controller and forecasting services load optional model artifacts; the inspected controller currently constructs random observation values.
Evidence, validation & limits+
Validation
Source reviewed on 15 October 2026. The application and its external integrations were not executed in this review.
Inspected signal observations, heuristic control, traffic routes, and forecast fallbacks. Historical simulation-improvement percentages were not reproduced or carried forward.
Limits
Random observations and fallback forecasts do not establish live traffic control, measured congestion reduction, or validated SUMO performance.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
A market-research interface combining retrieval, market data, and portfolio-oriented questions.
The idea
Market questions often need several kinds of context. Combine explicit data tools, portfolio arithmetic, and a streamed answer in one research interface.
My work
The implementation connects tool-driven market research with streamed answers and parsed portfolio context. The source scope is clearer than a general chatbot description, without implying profitable investment decisions.
Python
FastAPI
React
Features
Route research questions through market-data, news, technical-analysis, and portfolio tools.
Normalize CAMS-style CSV holdings into invested value, current value, and gain summaries.
Stream tool activity and responses to a React interface with stock-chart and portfolio views.
Architecture
React chat state and an SSE client connect to FastAPI streaming and portfolio-upload routes.
Python tool dispatch separates quote/news retrieval, indicators, and statement parsing; portfolio summaries become model context.
Evidence, validation & limits+
Validation
Source reviewed on 15 October 2026. The application and its external integrations were not executed in this review.
Reviewed tool dispatch, CAMS column normalization, safe numeric parsing, and technical-indicator fallback code. No quote freshness, answer accuracy, or investment-return evaluation was run.
Limits
External market/news availability and statement formats can change behavior. No financial-advice reliability or return is established.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
An educational dataset exploration and classifier-comparison dashboard.
The idea
Learn classifier comparison by putting dataset exploration, a consistent train/test split, and multiple model reports in one educational dashboard.
My work
The source brings exploratory charts, a reproducible split, classifier comparison, and prediction controls into one dashboard. The README lists a student team; individual implementation responsibility has not been independently established.
Python
Streamlit
scikit-learn
Features
Explore a tabular heart-disease dataset with distributions, correlations, and feature comparisons.
Compare K-nearest neighbors, logistic regression, and Gaussian Naive Bayes on one held-out split.
Inspect confusion matrices, classification reports, and input-based model predictions.
Architecture
A single Streamlit application loads heart.csv and caches its training/data-preparation function.
An 80/20 split precedes StandardScaler fitting on training data; the three scikit-learn estimators share transformed held-out inputs for comparison.
Evidence, validation & limits+
Validation
Source reviewed on 15 October 2026. The application and its external integrations were not executed in this review.
Inspected load_and_train, the three classifier definitions, prediction paths, and report calculations. Model scores were not rerun or presented as clinical evidence.
Limits
One dataset split does not establish clinical validity, calibration, generalization, or diagnostic safety.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
An interactive Java visualization exploring galaxy shapes and orbital motion.
The idea
Make procedural galaxy shapes and orbital motion explorable through a standalone desktop visualization with direct navigation controls.
My work
The implementation combines procedural scene generation, animated orbital views, custom rendering, and interactive exploration in a standalone Java desktop application.
Java
Swing
Features
Compare galaxy views and explore a hypothetical collision visualization.
Navigate the scene through zoom, pan, reset, mode controls, and star inspection.
Render procedural stars, nebulae, orbital motion, and explanatory overlays.
Architecture
A Java Swing JFrame hosts a custom JPanel simulation, with Java2D image rendering and input listeners.
Separate Star, Galaxy, Renderer, and SimPanel classes keep procedural scene data, projection/rendering, and interaction logic distinct within one source file.
Evidence, validation & limits+
Validation
Source reviewed on 15 October 2026. The application and its external integrations were not executed in this review.
Reviewed the Java source structure and interaction/rendering definitions. Compilation, frame rate, and physical-model accuracy were not tested in this review.
Limits
The collision and orbital views are educational visualizations, without validated astrophysical simulation accuracy.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
A road-emergency assistance concept exploring maps, contact discovery, and interface design.
The idea
Explore a location-first interface that groups nearby assistance services and provides clear contact/navigation entry points during a road-emergency scenario.
My work
The source combines location-based service grouping, contact/navigation presentation, and optional alert integration. This is an emergency-assistance concept, without demonstrated real-world dispatch behavior.
React
FastAPI
Leaflet
PWA
Features
Group nearby services into trauma, ambulance, police, and rescue categories.
Rank service results by straight-line distance and show a rough travel-time estimate.
Define an SOS SMS adapter and an assistance-text endpoint with static fallback content.
Architecture
React/TypeScript interface connects to a Python FastAPI backend with separate locator, alert, and assistance services.
Google Places lookup falls back to mock service records without a key; Twilio delivery and model-generated guidance are separate configured integrations.
Evidence, validation & limits+
Validation
Source reviewed on 15 October 2026. The application and its external integrations were not executed in this review.
Inspected Haversine distance ranking, mock-service fallback, SMS adapter, and guidance fallback. No message or emergency call was sent.
Limits
No responder availability, successful alert delivery, clinical guidance quality, or real emergency response is verified.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
A clinical-triage interface concept for experimenting with structured model responses.
The idea
Explore how a structured model response can be presented as an inspectable triage interface, with patient input, result fields, and session history together.
My work
The implementation focuses on structured-output parsing and a patient-analysis interface. It is an educational UI experiment; rendering a model response is separate from validating medical reasoning.
React
Groq
Features
Enter a sample or custom patient description and request a structured model response.
Display urgency, differential suggestions, action lists, and red-flag fields in a dashboard.
Reload earlier responses from a browser-session analysis log.
Architecture
React hooks manage patient input, request state, and session history in a dashboard component.
A browser-side Groq service sends the configured prompt and supplied key, strips Markdown fences, and parses the returned JSON for presentation.
Evidence, validation & limits+
Validation
Source reviewed on 15 October 2026. The application and its external integrations were not executed in this review.
Reviewed the Groq request/JSON parser and dashboard input/result structure. No patient analysis was submitted and no clinical benchmark was run.
Limits
No clinical validity, diagnostic accuracy, or medical-device qualification is established. Model-generated urgency and confidence fields are not calibrated evidence.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
A learning-companion prototype exploring guided questions, topic tracking, and study plans.
The idea
Build a study flow around topic sessions and guiding questions, with conversation history and progress signals that can be revisited.
My work
The source connects persistent topic sessions, a Socratic-style prompting flow, parsed progress signals, and a study dashboard.
Python
FastAPI
SQLite
React
Features
Start a topic-specific study session and keep its question/answer history.
Prompt for guiding questions and parse an accompanying model-generated mastery marker.
Display topic progress, stronger/weaker topics, and session summaries.
Architecture
React setup, session, chat, and dashboard views connect to a single FastAPI application.
SQLite stores users, sessions, messages, and mastery records; an HTTP client calls Groq and separates a MASTERY marker from displayed response text.
Evidence, validation & limits+
Validation
Source reviewed on 15 October 2026. The application and its external integrations were not executed in this review.
Reviewed SQLite initialization, session/chat routes, extract_mastery, history, and dashboard queries. No tutoring-quality or learning-outcome study was run.
Limits
Prompt instructions do not guarantee Socratic behavior. Mastery percentages and historic response-time claims are not independently validated.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
An educational X-ray classification experiment with convolutional and transformer models.
The idea
Explore convolutional and transformer-based X-ray classification as an educational comparison, with visual explanations and evaluation boundaries kept explicit.
My work
This preserves the educational image-classification research direction. It does not claim a reproduced fracture detector or an independently established personal implementation scope.
Python
PyTorch
GradCAM
Features
Archived educational intent: compare convolutional and transformer approaches to X-ray classification.
The retained stack names GradCAM for visual inspection; a matching trained artifact and attribution output were not available for review.
Architecture
The historical record describes a Python/PyTorch image-classification experiment with an explanation view.
Image preprocessing, patient-level dataset partitions, model checkpoints, and evaluation code remain unverified without the matching source.
Evidence, validation & limits+
Validation
No source inspection, model inference, patient-level leakage check, or held-out clinical evaluation was completed for this archived version.
Limits
No diagnostic accuracy or clinical usefulness is claimed. A heatmap alone would not validate a model's medical reasoning.
Older source can contain superseded descriptions. Numerical impact, adoption, awards, and deployment claims are not carried into this entry.
Earlier source may contain superseded claims. No production scale, financial impact, or unqualified benchmark is implied by an archive entry.
