Presentation Ref

SLIDE 1 – TEAM INFO

SLIDE 2-

· ​ Explain about cross platform availability – both webapp and android app

· ​ Provides expert guidance at minimal or no cost, making high-quality mentorship

affordable

· ​ Able to accommodate users and mentors from diverse fields and locations, making it a
versatile platform for different mentorship needs.

· ​ Chat – uses websockets to establish bi directional communication (websocket uses a

single TCP socket to achieve this low-latency communication). We’ll use AES-256
encryption to encrypt the data in rest(ie., static data that is stored in mongo) and we’ll use
TLS(transport layer security) for transit encryption.

Buzzwords: WebSockets, AES-256, NoSQL, low-latency, TLS.

· ​ Live Streaming - Built on WebRTC, enabling peer-to-peer media streaming with minimal
latency. For scaling we’re planning to implement CDN(content del networks) like aws
cloudfront for scalable distro. This is supported by adaptive bitrate streaming (ABR)
which reduces quality compromise whilst we scale. For very large scale - Stream data can
be managed via RTMP(learn what this is we can use this for live streaming (this rtmp
thing is for live stream alone not for video call)) servers and transcoded using
FFmpeg.

Buzzwords: WebRTC, CDN, ABR, RTMP, FFmpeg.

· ​ Recordings - are stored in cloud object storage (e.g., AWS S3 or Google Cloud
Storage), and accessed via secure signed URLs. HLS/DASH protocols ensure
compatibility across devices.

Buzzwords - DASH, signed URLs, cloud object storage.

· ​ Elastic search - Fast and accurate mentor and community search capabilities. Employs
Elasticsearch clusters with sharded indices and replication for fault tolerance and fast
 query responses. Inverted indices are used to optimize full-text searches, while
analyzers and tokenizers ensure better search accuracy and relevance.

​ ​ Buzzwords: Elasticsearch, sharded indices, inverted indices, analyzers,

replication.

· ​ AI driven ML algo for recommendation –

Recommendation System:

Match users with relevant resources or courses.Apply a model like matrix factorization
(e.g., using SVD) singular value decomposition, for user-item interaction data or a deep
learning model (like autoencoders or neural collaborative filtering) to recommend
based on user behavior .Imagine you have a user-item matrix, where each row represents
a user, each column represents an item, and each cell contains the interaction (e.g., rating,
like, view) between a user and an item. The goal of matrix factorization is to predict
missing entries, i.e., recommend items to users based on the available data. Implement a
ranking algorithm using NLP techniques (e.g., TF-IDF, BERT) to assess and rank
resources by relevance.

Live Captions

Use WebRTC to capture live audio and stream it to the captioning service. Use
speech-to-text APIs like Google Speech-to-Text, AWS Transcribe, or open-source models
like DeepSpeech for transcription.

Chatbot

Answer queries and provide guidance to users.custom model based on transformers (e.g.,
GPT, BERT).Train the chatbot on a dataset of common user queries, resources, and answers.
Or Use an NLP model like Rasa, Dialogflow, which allows multi language support,
integration with google assistant, context management and ease of deployment.

Course Review:

mplement a sentiment analysis model on course reviews using pretrained models like
BERT or RoBERTa to classify reviews as positive, negative, or neutral.Enable a star-rating
system based on user feedback and auto-generate summaries of the reviews using NLP
models for a comprehensive overview.

MLOps Infrastructure:
 ●​ Use tools like ZenML, Kubeflow, or MLflow to manage the lifecycle of your models
(training, deploying, monitoring).
●​ Use Docker containers for portability and Kubernetes for scaling model
deployments.
●​ Implement CI/CD pipelines for continuous model updates and automated
deployments.

· ​ Auto translation of messages –

· ​ E2EE -

WEBRTC WORKFLOW -

1. Basic Flow of WebRTC Communication

WebRTC involves three key steps:

1.​ Signaling: Exchange of metadata (SDP and ICE candidates) to initiate the connection.
2.​ Connectivity Establishment: Finding the best path between peers using ICE
framework.
3.​ Media Exchange: Sending and receiving media streams (audio, video) and data
channels.

2. Key Concepts and Terminology

1. Signaling Server

●​ Purpose: Helps peers discover each other and exchange metadata (SDP and ICE
candidates) necessary to establish a peer-to-peer connection.
●​ Role: Unlike traditional communication protocols, WebRTC doesn’t specify a
signaling protocol. Developers can use existing protocols like SIP, XMPP,
WebSockets, or custom solutions for signaling.
 ●​ Signaling Data: It primarily includes Session Description Protocol (SDP) messages
and ICE candidate information.

2. Session Description Protocol (SDP)

●​ Definition: A format for describing multimedia communication sessions, such as the

type of media (audio/video), codecs, resolution, and format of data being sent.
●​ Role: SDP messages are exchanged between peers to negotiate connection parameters
(like media codecs and encryption).
●​ Example: SDP contains information like:
○​ IP addresses
○​ Port numbers
○​ Media capabilities (e.g., audio/video codecs)

3. Interactive Connectivity Establishment (ICE)

●​ Definition: A framework that helps WebRTC to find the best path for communication
between two peers.
●​ How it works: ICE gathers potential connection candidates from different network
interfaces, including:
○​ Host candidates: Direct connection between peers on the same network.
○​ STUN candidates: Candidates gathered using a STUN server to find
public-facing IP addresses.
○​ TURN candidates: Relays communication via a TURN server if direct
peer-to-peer communication isn't possible.

4. STUN (Session Traversal Utilities for NAT) Server

●​ Purpose: STUN helps clients determine their public IP address and the type of NAT
(Network Address Translation) being used. This information is then communicated to
the other peer during the ICE negotiation process.
●​ Role: STUN server assists in NAT traversal by helping the client find its public IP and
port. This is crucial because WebRTC needs to establish a connection between peers
that might be behind different types of NATs and firewalls.

5. TURN (Traversal Using Relays around NAT) Server

●​ Purpose: Acts as a fallback solution when direct peer-to-peer communication fails,

typically due to restrictive NAT or firewall configurations.
●​ Role: TURN relays the media/data between peers, essentially serving as a proxy when
a direct connection cannot be established.
●​ Drawback: TURN servers introduce latency and can increase operational costs due to
the server load.

6. UDP (User Datagram Protocol)

 ●​ Role in WebRTC: WebRTC typically relies on UDP, which is a connectionless,
low-latency transport layer protocol ideal for real-time communication. UDP doesn’t
guarantee delivery or packet order, making it faster but less reliable than TCP.

3. Detailed Workflow of WebRTC

Here’s a step-by-step explanation of how WebRTC works:

1.​ Peer Discovery and Signaling

○​ The application must first initiate a connection. It does this by sending a
request (using any signaling protocol like WebSockets or SIP) to the signaling
server to locate another peer and exchange SDP and ICE candidate
information.
2.​ SDP Exchange
○​ The browser (or client) creates an offer SDP which contains information about
media formats (codecs) it supports, encryption methods, IP/port of media
channels, etc. This SDP offer is sent to the other peer via the signaling server.
○​ The receiving peer processes the SDP and responds with an answer SDP
containing its own media capabilities.
3.​ ICE Candidate Gathering
○​ Both peers then gather ICE candidates from various sources:
■​ Host candidates from local network interfaces (LAN IPs).
■​ STUN candidates from public IP addresses behind NATs (if any).
■​ TURN candidates in case a direct connection isn’t possible.
○​ The peers exchange these ICE candidates via the signaling server, after which
the ICE framework works to establish the most efficient communication path.
4.​ Connection Establishment
○​ Once the ICE candidates have been exchanged, both peers start checking the
available candidates and determine the best one based on connectivity checks.
○​ If a direct connection is possible (peer-to-peer), the connection is established.
If not, the communication falls back to using the TURN server.
5.​ DTLS Handshake
○​ A DTLS handshake takes place to establish a secure connection, encrypting
the media streams with SRTP.
6.​ Media/Data Transmission
○​ After the connection is established, media streams (audio/video) and data
channels are transmitted between the peers via UDP using SRTP (Secure
Real-time Transport Protocol) for secure communication.
○​ WebRTC also allows the transfer of arbitrary data using RTCDataChannel,
which also uses UDP for fast, low-latency communication.

4. Merits of WebRTC

●​ Low Latency: Direct peer-to-peer communication through UDP provides very low
latency, crucial for real-time applications like voice, video calls, and gaming.
 ●​ High Quality: Adaptive bitrate streaming ensures that the quality of the video/audio
adjusts dynamically based on network conditions, ensuring optimal user experience.
●​ Security: Built-in encryption (DTLS/SRTP) ensures that all communications are
secure, meeting modern security standards without additional configurations.
●​ Cross-Platform: WebRTC works across various browsers (Chrome, Firefox, Safari)
and platforms (web, iOS, Android), allowing a consistent experience.
●​ NAT Traversal: With the help of STUN and TURN servers, WebRTC can handle
NAT and firewall traversal, ensuring that peers can connect even from behind
restrictive networks.
●​ Open Source: WebRTC is open-source, meaning it is constantly updated and
improved by a large community, reducing costs and speeding up development.

SLIDE – 4 –

​ Backend: Node.js

●​ Role: Node.js will serve as the primary backend environment, handling API requests,
managing sessions, and integrating with WebRTC signaling.
●​ Benefits:
○​ Scalability: Node.js is non-blocking, making it efficient for handling real-time
communication, such as WebRTC signaling.
○​ Cross-platform: The backend is platform-agnostic, working seamlessly with
mobile apps (Kotlin) and web clients (React).
○​ Microservices architecture: Node.js can be used for microservices that
independently handle different services (auth, media management, AI
matching), allowing for modular development.
●​ Technologies:
○​ Express.js: For API routing and middleware.
○​ Socket.io: For real-time WebSocket communication and signaling server
implementation for WebRTC.

2. Frontend: React (Web) [explain about virtual dom and reconcillation algo ]

●​ Role: React will handle the web application interface.

●​ Benefits:
○​ Reusable Components: React allows for modular, reusable UI components
that can be shared across web and mobile.
○​ Real-Time Updates: Leveraging React’s state management alongside
WebRTC for real-time audio/video and chat updates.
○​ Progressive Web App (PWA): Can make the web app behave more like a
mobile app, with offline support and push notifications.
●​ Technologies:
○​ Redux: For state management across the app.
 ○​ WebRTC API: Direct integration in the browser for video, audio, and data
transmission.

Mobile: Kotlin (Android) – Shriram

Challenges
​ Legal (research more about this) –

Forget everything bro -> use DPDPA

​ · GDPR & CCPA: Ensuring compliance with GDPR (General Data
Protection Regulation) and CCPA (California Consumer Privacy Act) involves building a
robust data governance framework. This includes maintaining an audit trail for data
processing activities, implementing data minimization techniques, and enabling users to
exercise data access rights (e.g., data portability and right to erasure).

· Data Localization and Cross-border Data Transfer: Handling cross-border data

transfers requires adherence to standard contractual clauses (SCCs) and ensuring that data
residency requirements are met, particularly for regions enforcing data localization laws.

· Liability Management: Establishing legal safeguards for managing potential

liabilities arising from mentorship advice involves developing and enforcing terms of service
agreements, liability waivers, and dispute resolution mechanisms. Integration of risk
management systems for mentorship-related incidents using automated compliance
workflows to mitigate operational risk.

Tech (Mostly about scaling onli) –

​ · Microservices Architecture: Coordinating microservices across Node.js (backend),
Python (ML), and WebRTC signaling presents significant challenges in terms of service
orchestration and API consistency. Managing RESTful endpoints, WebSockets, and
STUN/TURN server interactions in a synchronized manner can lead to potential race
conditions and latency bottlenecks.
· Real-Time Synchronization: Achieving seamless real-time updates across clients (React
and Kotlin) via WebRTC and Socket.io requires handling network volatility and NAT
traversal issues, particularly when dealing with ICE candidate prioritization for peer
connections.

· Data Consistency: Ensuring eventual consistency between MongoDB’s distributed

database clusters and real-time sessions, especially when handling replica sets and sharded
clusters, introduces the risk of data synchronization lags during high-traffic periods.

· Concurrency Control: Managing simultaneous video, audio, and data streams on WebRTC
via UDP while guaranteeing QoS (Quality of Service) and avoiding jitter or packet loss
across diverse network conditions is a considerable challenge.

· Scalability: Balancing the load across horizontal scaling of Node.js instances while
ensuring stateful connections in WebRTC requires sophisticated load balancing techniques,
including sticky sessions and distributed signaling via Redis or Kafka.

Marketing (feasibility) –
o High Demand for Mentorship Platforms

o increasing need for remote learning, upskilling, and career

development across various industries

o lack of guidance

Manageable Initial Costs

o Cloud Infrastructure: Leveraging pay-as-you-go cloud services (AWS,

Google Cloud) and serverless computing (Lambda, Functions) keeps
initial costs low and scalable.

o Open-Source & Cross-Platform: Using open-source frameworks

(Node.js, React, WebRTC) and cross-platform tools (React Native,
Kotlin) reduces development expenses and speeds up deployment.

o Minimal Overhead: A remote-first strategy cuts operational costs,

allowing the focus on platform growth.

Sustainable Revenue
 o Commissions: Implementing a commission-based revenue model
using Stripe Connect ensures recurring income from each transaction
with automated payment processing.

o Premium Features: Offering tiered subscription plans with exclusive

features like advanced analytics, priority mentor access, and
session recordings drives additional revenue through value-added
services.

Strategies

1.​ Modular Development:

○​ Implement microservices architecture for scalability and streamlined updates. Use
CI/CD pipelines to automate testing and deployment, ensuring rapid and stable
releases.
2.​ Incentives & Education:
○​ Use growth hacking with referral programs, rewards, and freemium models.
Provide clear, AI-driven onboarding and interactive guides to simplify user adoption.
3.​ Legal Compliance:
○​ Consult legal experts to ensure compliance with GDPR, CCPA, and data protection
laws. Regular audits and robust terms of service help mitigate risks.