Deepika Sharma

I build practical software at the intersection of AI models, computer vision, and product interfaces. Across public repositories, the recurring pattern is consistent: start from a technical problem, prototype quickly, wire the system end-to-end, and make it usable via web UIs, APIs, dashboards, or demo deployments.

My GitHub work shows three repeatable tracks:

1. Applied intelligence systems (traffic optimization, credibility/fact analysis, detection pipelines).
2. Product-oriented full stack builds (React frontends + API layers + data stores).
3. Engineering depth practice through algorithms, DSA, and tooling-heavy experiments.

This profile README is intentionally grounded only in public repository evidence (repo metadata, code structure, README docs, dependencies, and visible demos).

                         ┌──────────────────────────────────────┐
                         │        Real-world problem space      │
                         │  traffic, trust, learning, workflow  │
                         └──────────────────────────────────────┘
                                          │
                                          ▼
┌──────────────────────────────┐   ┌──────────────────────────────┐
│ AI/ML Core                   │   │ Computer Vision              │
│ - NLP/classification         │   │ - YOLO-based detection       │
│ - credibility scoring        │   │ - deepfake/face pipelines    │
│ - model experiments          │   │ - stream/video processing    │
└──────────────────────────────┘   └──────────────────────────────┘
                │                               │
                └───────────────┬───────────────┘
                                ▼
                  ┌──────────────────────────────┐
                  │ Full-Stack Product Layer     │
                  │ React / Node / FastAPI / UI  │
                  └──────────────────────────────┘
                                │
                                ▼
                  ┌──────────────────────────────┐
                  │ APIs, Data, Integrations     │
                  │ PostgreSQL/MongoDB/AWS/etc.  │
                  └──────────────────────────────┘
                                │
                                ▼
                  ┌──────────────────────────────┐
                  │ Developer Tooling & DSA      │
                  │ C++ analysis, algorithms     │
                  └──────────────────────────────┘

Only technologies that appear in repository metadata, dependency files, project structure, or READMEs are included.

• QuickFactChecker — fake-news credibility app with ML model variants and Flask web flow.
• VertiasAI (VeritasAI) — credibility analysis API + retrieval + audit stack.
• Fake-News-detection — notebook-based fake-news modeling.
• Disease-Predictor-ML — ML classification prototype.
• Fraud-Detection — experiment-oriented detection repo.

• VARUNA — accident detection + smart traffic signal optimization.
• DeepFake-Detection — deepfake image detection flow.
• FACE-RECOGNITION-USING-IMAGES-AND-WEBCAM — image/webcam face recognition scripts.

• Intervirew_prep — multi-part app with frontend, backend, and ML folders.
• EventMint — event management UI flow with React ecosystem.
• pharmaAI — full-stack hackathon demo (React + Express backend).
• pdfchatbot — PDF chat interface with TS frontend + Python API stack.
• FutureMart — TypeScript web app repository.
• SkillExchange, SkillForge

• CodeAtlas-AI — repository analysis platform (C++ + React).
• DSA — algorithm and problem-solving repository.
• CodeInsight — C#-based code-related work.

• QuickFactChecker — explicit GSSoC’25 onboarding content in README.
• Pathsphere — open-source resource platform structure with contributor docs.
• EventMint — contribution-centric README and collaboration steps.

• AISim
• ExamineAI
• Secret_Intelligence
• SILIGURI-AI
• Email_Logger

[Camera/Video Stream]
        |
        v
[YOLO Detection Layer] ---> [Vehicle/Incident Counters]
        |                             |
        v                             v
[Smart Signal Controller] ---> [Decision Payload API]
        |
        v
[FastAPI WebSocket Endpoint] ---> [React Dashboard]
        |
        v
[Evidence Archive + Alert Hooks]

[Input: text/url/image/pdf]
            |
            v
[FastAPI /analyze endpoint]
            |
            +--> [Extraction: OCR/PDF parsing]
            |
            +--> [Retriever: web evidence + requests/bs4]
            |
            +--> [GenAI analysis + scoring]
            |
            v
[Audit storage: PostgreSQL + local logs]
            |
            v
[Response: verdict + evidence + explanation]

[React + Vite UI]
      |
      v
[/api proxy]
      |
      v
[Express Backend Routes]
      |
      +--> [mock_response.json (current default)]
      |
      +--> [planned Python LLM service integration]

[React Frontend]
      |
      v
[Routing + Event UI Components]
      |
      v
[Node/Express Service Layer]
      |
      v
[Data + Registration + Payment workflow docs]

1. VARUNA

   • YOLO-powered object/incident detection
   • OpenCV stream processing
   • Incident-aware traffic control logic

2. DeepFake-Detection

   • Keras model loading
   • Streamlit image upload and prediction UI
   • Confidence and label generation

3. FACE-RECOGNITION-USING-IMAGES-AND-WEBCAM

   • Webcam/image mode scripts
   • Haar cascade file in repository

4. VertiasAI

   • OCR + PDF parsing support alongside NLP credibility pipeline

Input stream/image
   -> pre-processing
   -> model inference
   -> label/confidence
   -> response orchestration
   -> UI/dashboard delivery

The repositories repeatedly show this technical sequence:

Frontend (React/Vite/JS)
   ↓
API Gateway / Route layer (Express/FastAPI)
   ↓
Business logic (analysis, auth, scoring, workflows)
   ↓
Storage (MongoDB/PostgreSQL/DynamoDB/S3/files)
   ↓
Deployment/Preview (Render/Vercel/local scripts)

• Intervirew_prep
• VertiasAI
• pharmaAI
• EventMint
• pdfchatbot
• QuickFactChecker (full app + deployment docs)

• QuickFactChecker README explicitly references GSSoC'25 participation and contributor workflows.
• Multiple repositories include CONTRIBUTING.md, code of conduct files, and issue/PR templates.
• Collaboration-first repositories include public contribution instructions (EventMint, Pathsphere, QuickFactChecker).

I avoid claiming unverified metrics (PR counts, awards, merged contribution totals) in this profile README. Where community activity is shown, it is tied to visible repository documentation.

• Commit and repository activity can be tracked live via the graph above.
• The profile prioritizes dynamic widgets for freshness instead of hardcoding static counts.
• Most recent repository updates indicate continued engineering across C++ tools, DSA, and AI-oriented projects.

Based on visible updated_at patterns and recent repositories:

• Expanding CodeAtlas-AI style tooling ideas (repo analysis + DSA-backed features).
• Continuing DSA problem-solving iterations.
• Maintaining AI/project portfolio repos and profile infrastructure.

If specific in-progress production milestones are private, this section intentionally stays conservative.

• Higher-complexity repository intelligence tooling patterns
• AI-assisted verification and credibility systems
• Full-stack architecture hardening (security middleware, logging, API limits)
• Better bridge between model prototypes and polished UX

1. Build useful interfaces around models — a model alone is not a product.
2. Ship end-to-end prototypes — UI, API, inference, and data flow should meet.
3. Document for contributors — reproducible setup and contribution paths matter.
4. Iterate in public — experiments, drafts, and polished apps can coexist.
5. Balance breadth with systems thinking — AI, CV, web engineering, and tools can reinforce each other.

• This section intentionally reuses live widgets rather than static snapshots.
• Repository-level velocity varies by project lifecycle (hackathon, experiment, maintenance, feature build).

1. Foundational coding and algorithms

   • DSA, language-focused repositories, and problem-solving projects.

2. Model experimentation and applied AI

   • fake-news, deepfake, disease/fraud-themed repositories.

3. End-to-end productization

   • VARUNA, VertiasAI, Intervirew_prep, pharmaAI, EventMint.

4. Tool-building and systems architecture exploration

   • CodeAtlas-AI, cloud-integrated backend patterns, structured project organization.

✅ indicates repository evidence supports the capability area.