VideoHub Roadmap

Roadmap generated from real build history

This page is derived from commit activity in commit_history.csv. It summarizes what has been shipped and what Programmer Tech is prioritizing next.

Commits analyzed: 225 · Last update in history: 2026-06-20

Back to Company Landing Page

Execution Signals

Authentication & Identity

32 related commits

Most recent: 2026-06-04

  • Derive live auth context
  • Fix auth test for changed logout functionality
  • Fix header forwarding from alb for auth

Recommendation & Relevance

26 related commits

Most recent: 2026-06-10

  • Add shorts recs panel
  • Remove duplicate candidate generators from Gorse
  • Restore IsRecommendable when failed item is enriched

Ingestion & Platform Data

23 related commits

Most recent: 2026-06-10

  • Separate VODs and shorts format
  • Fix Twitch auto-pause on focus loss
  • Close prior active stream when stream IDs change

Product Experience

18 related commits

Most recent: 2026-06-20

  • Honor disabled social logins and defer theme reads after hydrations
  • UI rework for navigation and layout
  • Mandate impression before watch event

Infrastructure & Reliability

16 related commits

Most recent: 2026-06-02

  • Backfill label migration
  • AddChannels migration
  • Automatically apply migrations in preview

Search & Discovery

14 related commits

Most recent: 2026-06-06

  • Fix YouTube discovery enrichment state updates
  • Improve pre-enrichment normalized labels
  • Promote normalized labels pre and post enrichment sync paths

Roadmap Priorities

Completed · Recommendation Pipeline Revamp

A previous release moved recommendation serving beyond a single raw Gorse list. VideoHub now builds blended candidate pools, applies eligibility and safety filters, scores candidates with user/content features, reranks for diversity, and can return explanation/debug metadata.

Implemented · User Settings

The latest work added user-facing settings for account connections, language preferences, homepage configuration, shortform recommendations, theme preference, OAuth login controls, and two-factor authentication management.

  • Add or remove connected YouTube/Twitch accounts.
  • Add or remove preferred recommendation languages.
  • Enable or disable recommended shortform content.
  • Choose dark, light, or system theme.
  • Allow or disallow login through connected OAuth accounts.
  • Manage 2FA through TOTP apps, passkeys/FIDO2, or primary-email verification.

In Progress · Platform Subscription Tracker

Pull follows and subscriptions from each connected platform, then feed those creator relationships into content synchronization and personalized recommendations.

Planned · Federated Content Identity

Resolve cross-platform creator identity automatically so notifications can be compressed, watched-content suppression improves, and VODs can inherit attribution from their related live streams.

Planned · Native Feedback & Comments

Add platform-native likes/dislikes, finer-grained controls such as "stop recommending content like this," sharing, and a mixed comment section that blends VideoHub comments with top platform-sourced comments.

Backend Architecture Overview

VideoHub backend is a distributed ASP.NET Core + worker-based platform for ingesting YouTube/Twitch content, normalizing it into canonical content items, collecting interaction feedback, and serving recommendations through an application-owned recommendation pipeline. Gorse remains the specialized candidate engine and neighbor store, while RecommendationPipelineService blends candidates from Gorse and SQL-backed sources, applies product eligibility and safety filters, scores candidates with user/profile/content features, diversity-reranks the final set, and returns explanation/debug metadata when requested.

Core loop: discover/sync content -> normalize and label items -> sync recommendation-ready items to Gorse -> collect feedback -> aggregate engagement -> sync feedback to Gorse -> generate blended candidates -> filter, score, and diversity-rerank -> collect new feedback.

High-Level Diagram

[Client Web App]
       | JWT/API calls + feedback events
       v
[API (ASP.NET Core)] --- [Auth (Identity/JWT)]
       |       |
       |       +--> [RecommendationPipelineService]
       |       |          |--> [Candidate Engine: Gorse]
       |       |          |--> [SQL metadata/profile/eligibility]
       |       |          +--> [Ranked recommendations + explanations]
       |       |
       |       +--> [RecommendationPerformanceService]
       |
       +--> [App Data Store: SQL Server / RDS-equivalent]
       +--> [Queue: AWS SQS / LocalStack]
                    |
                    v
              [Workers: Discovery / Sync / Enrichment / Feedback Aggregation /
               Gorse Sync / Embedding]
                    |       |        |
                    |       |        +--> [Embeddings: AWS Bedrock]
                    |       +--> [Labeling + Normalization]
                    +--> [YouTube + Twitch APIs/EventSub]

[Candidate Engine: Gorse] --> [Gorse Data Store: MySQL + Redis]

Core Services

  • Client (Web app): Captures user actions, renders feeds/watch pages, and emits impressions, clicks, reads, watch heartbeats, and explicit feedback.
  • API (ASP.NET Core): Handles auth, content resolution, search, recommendation serving, feedback ingestion, admin performance reporting, and queue publishing.
  • RecommendationPipelineService: Merges candidate sources, applies eligibility filters, computes ranking features, scores candidates, diversity-reranks results, and emits optional explanation/debug data.
  • Auth (Identity/JWT): Manages identities, external account links, JWT issuance, validation, revocation cutoffs, and admin policy enforcement.
  • App Data Store: Source of truth for users, connected accounts, content items, feedback events, engagement aggregates, EventSub state, and recommendation eligibility.
  • Queue (SQS): Decouples request path from async jobs (enrichment, feedback aggregation, EventSub processing) with retry/visibility semantics.
  • Workers: Execute periodic and event-driven pipelines for discovery, sync, enrichment, aggregation, embedding, and Gorse synchronization.
  • Labeling + Normalization: Converts content metadata and labeler votes into consistent platform, format, status, game/topic, language, safety, and audience labels.
  • Candidate Engine (Gorse): Stores recommendation-ready users/items/feedback, maintains collaborative and neighbor models, and returns candidate seeds.
  • Embeddings (Bedrock + Embedding Worker): Generates vectors from content text and patches embeddings into Gorse item labels.
  • RecommendationPerformanceService: Aggregates recommendation-source feedback into admin metrics such as impressions, CTR, read/watch rates, top items, and daily series.

Data Model (Core Entities)

  • ApplicationUser
  • ConnectedAccount
  • RefreshToken
  • ContentItem
  • FeedbackEvent
  • UserItemEngagement
  • EventSubSubscription
  • EventSubCandidate
  • TwitchStreamRecord

Critical Pipelines

  • Content ingestion/catalog sync: Workers poll YouTube/Twitch, upsert canonical items, normalize labels, sync eligible items to Gorse, and patch embeddings later.
  • Feedback: API accepts idempotent events, stores raw feedback, queues aggregation, materializes user-item engagement, then upserts final feedback values to Gorse.
  • Recommendation serving: Pipeline builds user profiles, blends Gorse and SQL candidate pools, filters, scores, reranks, and returns explanations/debug data when requested.
  • Related video serving: Watch pages ask for item neighbors from Gorse and map labels back into frontend-ready content payloads.
  • Performance reporting: Admin APIs attribute downstream events to recommendation impressions and return quality metrics over time.

Reliability + Idempotency

  • Feedback dedupe by immutable event ID.
  • Content uniqueness on platform + externalId + kind.
  • SQS long polling + visibility timeout + explicit ack on success.
  • Processed markers prevent double aggregation.
  • Gorse feedback uses aggregate upsert semantics.
  • Serving-time filters recheck local DB state when Gorse returns stale IDs.

Scaling & Performance

  • Stateless API scales horizontally behind proxy/load balancer.
  • Worker classes scale independently by workload type.
  • Queue buffering smooths burst traffic.
  • Batch processing and targeted indexes optimize throughput.
  • Candidate pools over-fetch within bounded limits to preserve diversity after filtering.
  • Gorse + MySQL/Redis stays isolated from transactional SQL Server workload.

Security & Compliance

  • JWT bearer auth with issuer/audience/signing key validation.
  • Refresh/access token protection, rotation, and revocation handling.
  • Admin recommendation performance APIs require admin policy.
  • Safety labels and mature/adult filters default unsafe content out of recommendations.
  • TLS via reverse proxy in production + controlled CORS origins.
  • Least-privilege AWS access for SQS and Bedrock integrations.