Forem: Naman

📊 Extracting DSA Question Statistics from Codolio and TakeUForward (TUF)

Naman — Sat, 10 Jan 2026 04:40:20 +0000

If you're actively solving DSA problems across multiple platforms (LeetCode, GeeksforGeeks, Codeforces, TakeUForward) and also contributing to GitHub, wouldn't it be amazing to have one unified dashboard showing all your coding stats? In this tutorial, I'll show you how I built a Complete Coding Stats Aggregator that combines:

DSA Stats from Codolio (LeetCode, GFG, Codeforces, etc.)
TakeUForward progress separately
GitHub Activity (commits, stars, PRs, active days)

All exported to a single coding-stats.json file!

🎯 What We're Building

A Python script that:

✅ Fetches coding stats from Codolio API (all platforms except TUF)
✅ Fetches TakeUForward stats separately (to avoid duplication)
✅ Fetches GitHub activity stats from Codolio's GitHub proxy
✅ Combines everything into coding-stats.json
✅ Categorizes DSA problems by difficulty: Easy, Medium, Hard

🔍 Step 1: Reverse Engineering the APIs

1.1 Finding the Codolio API

Goal: Get your DSA stats from all platforms (except TUF)

Open Codolio Profile: Go to codolio.com and log in
Open Developer Tools:
- Windows/Linux: F12 or Ctrl+Shift+I
- Mac: Cmd+Option+I
Go to Network Tab: Click on the "Network" tab
Reload the Page: Press Ctrl+R (Windows/Linux) or Cmd+R (Mac)
Filter Requests: Type "user" in the filter box
Locate the API Call: Look for a request to https://api.codolio.com/user
Extract Headers:
- Click on the request
- Go to "Headers" section
- Find authorization header
- Copy the entire Bearer token (starts with Bearer eyJ...)

API Endpoint: https://api.codolio.com/user

What you need:

Authorization token (Bearer token from headers)

1.2 Finding the TakeUForward API

Goal: Get your TUF-specific stats

Open Your TUF Profile: Visit https://takeuforward.org/profile/YOUR_USERNAME
Open Developer Tools: F12
Go to Network Tab: Click "Network"
Reload Page: Ctrl+R
Filter: Type "dsa-progress"
Find the Endpoint: Look for:

   https://backend-go.takeuforward.org/api/v1/shared/profile/dsa-progress/YOUR_USERNAME

API Endpoint: https://backend-go.takeuforward.org/api/v1/shared/profile/dsa-progress/{username}

What you need:

Your TUF username (no authentication required!)

1.3 Finding the GitHub Stats API (via Codolio)

Goal: Get GitHub activity stats

On Codolio Profile: Make sure your GitHub is connected
Open Developer Tools: F12
Network Tab: Click "Network"
Navigate to GitHub Section: Click on your GitHub stats in Codolio
Filter: Type "github"
Find the Endpoint: Look for:

   https://api.codolio.com/github/profile?userKey=YOUR_PROFILE_NAME

API Endpoint: https://api.codolio.com/github/profile?userKey={profileName}

What you need:

Your Codolio profile name (username)

🛠️ Step 2: Understanding the Data Structures

2.1 Codolio Response (DSA Stats)

{
  "data": {
    "platformProfiles": {
      "platformProfiles": [
        {
          "platform": "leetcode",
          "totalQuestionStats": {
            "easyQuestionCounts": 150,
            "mediumQuestionCounts": 200,
            "hardQuestionCounts": 50,
            "totalQuestionCounts": 400
          }
        },
        {
          "platform": "gfg",
          "totalQuestionStats": {
            "basicQuestionCounts": 100,
            "schoolQuestionCounts": 50,
            "easyQuestionCounts": 120,
            "mediumQuestionCounts": 80,
            "hardQuestionCounts": 30,
            "totalQuestionCounts": 380
          }
        },
        {
          "platform": "tuf",
          "totalQuestionStats": { /* we skip this */ }
        }
      ]
    }
  }
}

Key Points:

Contains multiple platforms in one response
Some platforms (like GFG) have basicQuestionCounts and schoolQuestionCounts → treat as Easy
TUF is included but we skip it to avoid double-counting

2.2 TakeUForward Response

{
  "data": {
    "data": {
      "solvedEasy": 45,
      "solvedMedium": 60,
      "solvedHard": 15,
      "totalSolved": 120
    }
  }
}

2.3 GitHub Response (via Codolio)

{
  "data": {
    "githubProfile": "naman08",
    "stars": 42,
    "issues": 15,
    "totalActiveDays": 365,
    "pushRequestsCount": 89,
    "totalContributions": 1247
  }
}

💻 Step 3: Writing the Complete Aggregator Script

3.1 Install Required Package

pip install requests

3.2 The Complete Script

Create a file aggregator.py:

import requests
import json
import os

# =========================
# 1️⃣ CODOLIO (ALL EXCEPT TUF)
# =========================
codolio_url = "https://api.codolio.com/user"

codolio_headers = {
    "authorization": "Bearer YOUR_TOKEN_HERE",  # 🔥 REPLACE THIS
    "accept": "*/*",
    "referer": "https://codolio.com/"
}

res = requests.get(codolio_url, headers=codolio_headers)

if res.status_code != 200:
    print("❌ Codolio Error:", res.status_code)
    exit()

data = res.json()
platforms = data["data"]["platformProfiles"]["platformProfiles"]

codolio_easy = codolio_medium = codolio_hard = codolio_total = 0

for p in platforms:
    if p.get("platform") == "tuf":
        continue  # ❌ Skip TUF to avoid duplicates

    q = p.get("totalQuestionStats")
    if not q:
        continue

    # Standard difficulty counts
    codolio_easy += q.get("easyQuestionCounts") or 0
    codolio_medium += q.get("mediumQuestionCounts") or 0
    codolio_hard += q.get("hardQuestionCounts") or 0

    # Platform-specific easy categories (GFG, etc.)
    # Treat "basic" and "school" level as Easy
    codolio_easy += q.get("basicQuestionCounts") or 0
    codolio_easy += q.get("schoolQuestionCounts") or 0

    codolio_total += q.get("totalQuestionCounts") or 0

print(f"✅ Codolio: {codolio_total} problems")


# =========================
# 2️⃣ TUF OFFICIAL API
# =========================
tuf_url = "https://backend-go.takeuforward.org/api/v1/shared/profile/dsa-progress/YOUR_USERNAME"  # 🔥 REPLACE

tuf_headers = {
    "accept": "application/json, text/plain, */*",
    "origin": "https://takeuforward.org",
    "referer": "https://takeuforward.org/"
}

res = requests.get(tuf_url, headers=tuf_headers)

if res.status_code != 200:
    print("❌ TUF Error:", res.status_code)
    exit()

tuf_data = res.json()["data"]["data"]

tuf_easy = tuf_data["solvedEasy"]
tuf_medium = tuf_data["solvedMedium"]
tuf_hard = tuf_data["solvedHard"]
tuf_total = tuf_easy + tuf_medium + tuf_hard

print(f"✅ TUF: {tuf_total} problems")


# =========================
# 3️⃣ FINAL DSA COMBINED
# =========================
final_easy = codolio_easy + tuf_easy
final_medium = codolio_medium + tuf_medium
final_hard = codolio_hard + tuf_hard
final_total = final_easy + final_medium + final_hard

print(f"📊 Total DSA: {final_total} problems")


# =========================
# 4️⃣ GITHUB STATS (FROM CODOLIO)
# =========================
github_url = "https://api.codolio.com/github/profile?userKey=YOUR_PROFILE_NAME"  # 🔥 REPLACE

github_headers = {
    "accept": "*/*",
    "referer": "https://codolio.com/"
}

try:
    res = requests.get(github_url, headers=github_headers, timeout=15)

    if res.status_code != 200:
        raise Exception(f"GitHub API error {res.status_code}")

    github_json = res.json()
    gh = github_json.get("data", {})  # ✅ Extract the "data" object

    github_data = {
        "githubProfile": gh.get("githubProfile"),
        "stars": gh.get("stars", 0),
        "issues": gh.get("issues", 0),
        "totalActiveDays": gh.get("totalActiveDays", 0),
        "pushRequestsCount": gh.get("pushRequestsCount", 0),
        "commits": gh.get("totalContributions", 0)
    }

    print(f"✅ GitHub: {github_data['commits']} commits")

except Exception as e:
    print(f"⚠️ GitHub fetch failed: {e}")
    github_data = {}


# =========================
# 5️⃣ COMBINE & EXPORT JSON
# =========================
output = {
    "codolio": {
        "easy": codolio_easy,
        "medium": codolio_medium,
        "hard": codolio_hard,
        "total": codolio_total
    },
    "tuf": {
        "easy": tuf_easy,
        "medium": tuf_medium,
        "hard": tuf_hard,
        "total": tuf_total
    },
    "final": {
        "easy": final_easy,
        "medium": final_medium,
        "hard": final_hard,
        "total": final_total
    },
    "github": github_data
}

# Create public directory if it doesn't exist
os.makedirs("public", exist_ok=True)

with open("public/coding-stats.json", "w") as f:
    json.dump(output, f, indent=2)

print("\n🎉 coding-stats.json generated successfully!")
print(f"📍 Location: public/coding-stats.json")

3.3 Replace Placeholders

Before running, replace:

Line 10: YOUR_TOKEN_HERE → Your Codolio Bearer token
Line 44: YOUR_USERNAME → Your TakeUForward username
Line 73: YOUR_PROFILE_NAME → Your Codolio profile name (e.g., naman08)

📤 Step 4: Run the Script

python aggregator.py

Expected Output:

✅ Codolio: 630 problems
✅ TUF: 120 problems
📊 Total DSA: 750 problems
✅ GitHub: 1247 commits

🎉 coding-stats.json generated successfully!
📍 Location: public/coding-stats.json

Generated File (public/coding-stats.json):

{
  "codolio": {
    "easy": 270,
    "medium": 280,
    "hard": 80,
    "total": 630
  },
  "tuf": {
    "easy": 45,
    "medium": 60,
    "hard": 15,
    "total": 120
  },
  "final": {
    "easy": 315,
    "medium": 340,
    "hard": 95,
    "total": 750
  },
  "github": {
    "githubProfile": "naman08",
    "stars": 42,
    "issues": 15,
    "totalActiveDays": 365,
    "pushRequestsCount": 89,
    "commits": 1247
  }
}

🔄 Step 5: Automate with GitHub Actions

Create .github/workflows/update-stats.yml:

name: Update Coding Stats

on:
  schedule:
    - cron: '0 0 * * *'  # Run daily at midnight UTC
  workflow_dispatch:  # Allow manual trigger

jobs:
  update-stats:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout repository
        uses: actions/checkout@v3

      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.10'

      - name: Install dependencies
        run: pip install requests

      - name: Run aggregator script
        env:
          CODOLIO_TOKEN: ${{ secrets.CODOLIO_TOKEN }}
          TUF_USERNAME: ${{ secrets.TUF_USERNAME }}
          CODOLIO_PROFILE: ${{ secrets.CODOLIO_PROFILE }}
        run: |
          # Replace placeholders in script
          sed -i "s/YOUR_TOKEN_HERE/$CODOLIO_TOKEN/g" aggregator.py
          sed -i "s/YOUR_USERNAME/$TUF_USERNAME/g" aggregator.py
          sed -i "s/YOUR_PROFILE_NAME/$CODOLIO_PROFILE/g" aggregator.py

          # Run the script
          python aggregator.py

      - name: Commit and push changes
        run: |
          git config --local user.email "action@github.com"
          git config --local user.name "GitHub Action"
          git add public/coding-stats.json
          git diff --staged --quiet || git commit -m "📊 Update coding stats [$(date +'%Y-%m-%d')]"
          git push

Add GitHub Secrets

Go to your repository → Settings → Secrets and variables → Actions → New repository secret:

CODOLIO_TOKEN: Your Bearer token (without "Bearer " prefix)
TUF_USERNAME: Your TakeUForward username
CODOLIO_PROFILE: Your Codolio profile name

🎯 Conclusion

You now have a fully automated coding stats aggregator that combines:

✅ Multi-platform DSA progress (via Codolio + TUF)
✅ GitHub activity metrics
✅ Auto-updates via GitHub Actions
✅ Ready-to-display JSON format

Perfect for portfolios, resumes, or tracking your coding journey!

Found this helpful? Star the repo and share with fellow developers! 🌟

Happy Coding! 🚀

Mall Customer Segmentation using ML — A Step-by-Step Tutorial

Naman — Mon, 13 Oct 2025 09:00:37 +0000

🧠 Introduction

In this project, we explore Customer Segmentation using the famous Mall Customers Dataset. We'll apply KMeans Clustering to group similar customers and Random Forest Regression to predict spending scores. Finally, we’ll deploy the model with Streamlit.

📊 Dataset Overview

We use the Mall_Customers.csv dataset from Kaggle. It contains information about 200 customers:

Column	Description
CustomerID	Unique identifier
Genre	Male / Female
Age	Customer’s age
Annual Income (k$)	Annual income in thousand dollars
Spending Score (1–100)	Score assigned by the mall

⚙️ Step 1: Import Required Libraries

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.cluster import KMeans
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import r2_score
import joblib

🧹 Step 2: Load and Preprocess Data

# Load dataset
df = pd.read_csv('Mall_Customers.csv')

# Clean columns
df.columns = df.columns.str.strip()

# Encode Gender
le = LabelEncoder()
df['Genre'] = le.fit_transform(df['Genre'])  # Female=0, Male=1

# Drop CustomerID
X = df.drop(['CustomerID'], axis=1)

🧩 Step 3: Feature Scaling

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X[['Age', 'Annual Income (k$)', 'Spending Score (1–100)']])

# Save scaler
joblib.dump(scaler, './Models/scaler.pkl')

🌀 Step 4: KMeans Clustering

# Find optimal number of clusters using Elbow Method
inertia = []
for k in range(1, 11):
    kmeans = KMeans(n_clusters=k, random_state=42)
    kmeans.fit(X_scaled)
    inertia.append(kmeans.inertia_)

plt.plot(range(1, 11), inertia, marker='o')
plt.title('Elbow Method')
plt.xlabel('Number of clusters')
plt.ylabel('Inertia')
plt.show()

# Train KMeans
kmeans = KMeans(n_clusters=5, random_state=42)
df['Cluster'] = kmeans.fit_predict(X_scaled)

# Save the model
joblib.dump(kmeans, './Models/classifier.pkl')

📈 Step 5: Visualize Clusters

plt.figure(figsize=(8, 6))
plt.scatter(df['Annual Income (k$)'], df['Spending Score (1–100)'], c=df['Cluster'], cmap='viridis')
plt.xlabel('Annual Income (k$)')
plt.ylabel('Spending Score (1–100)')
plt.title('Customer Segments')
plt.show()

🧮 Step 6: Predicting Spending Score (Regression)

# Features and target
X_rf = df[['Genre', 'Age', 'Annual Income (k$)']]
y_rf = df['Spending Score (1–100)']

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(X_rf, y_rf, test_size=0.2, random_state=42)

# Train Random Forest
rf = RandomForestRegressor(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)

# Evaluate
preds = rf.predict(X_test)
print(f'R² Score: {r2_score(y_test, preds):.2f}')

# Save model
joblib.dump(rf, './Models/Spending_Score.pkl')

🌐 Step 7: Streamlit App for Deployment

Create a new file named app.py:

import streamlit as st
import joblib
import numpy as np

# Load models
scaler = joblib.load('./Models/scaler.pkl')
kmeans = joblib.load('./Models/classifier.pkl')
rf = joblib.load('./Models/Spending_Score.pkl')

st.title('🛍️ Mall Customer Segmentation')

# Inputs
gender = st.selectbox('Gender', ['Female', 'Male'])
age = st.number_input('Age', 18, 70)
income = st.number_input('Annual Income (k$)', 10, 150)

# Encode gender
gender_encoded = 0 if gender == 'Female' else 1

# Predict Spending Score
predicted_score = rf.predict([[gender_encoded, age, income]])[0]

# Predict Cluster
scaled_features = scaler.transform([[age, income, predicted_score]])
cluster = kmeans.predict(scaled_features)[0]

st.subheader(f'💰 Predicted Spending Score: {predicted_score:.2f}')
st.subheader(f'📊 Predicted Cluster: {cluster}')

🪄 Step 8: Run the Streamlit App

streamlit run app.py

Then open the provided localhost link to access your interactive dashboard.

🎯 Conclusion

You’ve successfully built and deployed a full Machine Learning + Streamlit project!

What You Learned

How to preprocess and scale data
Perform KMeans clustering for segmentation
Train Random Forest for regression
Deploy with Streamlit for interactivity

💻 Author: Naman Srivastava
📅 Date: October 2025
🔗 GitHub: Mall Customer Segmentation Project

Build a Secure, Real-Time Chat App in Minutes with React, Clerk, and Stream

Naman — Tue, 09 Sep 2025 16:27:09 +0000

🚀 Chat Application Setup Guide

A complete guide to set up and run your React chat application using Clerk authentication and Stream Chat.

📋 Prerequisites

Before you start, make sure you have:

Node.js (version 14 or higher) installed on your computer
npm or yarn package manager
A code editor (VS Code recommended)
Basic knowledge of React

🏗️ Project Structure

Your project should have the following structure:

my-chat-app/
├── src/
│   ├── App.jsx
│   ├── appli.css
│   └── main.jsx
├── .env
├── package.json
└── README.md

🔧 Step 1: Initialize Your React Project

Create a new React project using Vite:

   npm create vite@latest my-chat-app -- --template react
   cd my-chat-app

Install required dependencies:

   npm install @clerk/clerk-react stream-chat stream-chat-react

🔑 Step 2: Set Up Authentication (Clerk)

Create a Clerk Account

Go to clerk.com and sign up for a free account
Create a new application
Copy your Publishable Key from the Clerk dashboard

Configure Clerk in Your App

Wrap your main App component with ClerkProvider in src/main.jsx:

   import React from 'react'
   import ReactDOM from 'react-dom/client'
   import { ClerkProvider } from '@clerk/clerk-react'
   import App from './App.jsx'

   const CLERK_PUBLISHABLE_KEY = import.meta.env.VITE_CLERK_PUBLISHABLE_KEY

   ReactDOM.createRoot(document.getElementById('root')).render(
     <React.StrictMode>
       <ClerkProvider publishableKey={CLERK_PUBLISHABLE_KEY}>
         <App />
       </ClerkProvider>
     </React.StrictMode>,
   )

💬 Step 3: Set Up Chat (Stream)

Create a Stream Account

Go to getstream.io and sign up for a free account
Create a new Chat application
Note down your API Key from the dashboard

Generate User Tokens Manually

Stream requires user tokens for authentication. Since your code already handles two specific users (alice and bob based on email), you'll need to generate tokens for these exact user IDs.

Using Stream's JWT Generator

You can generate a token manually using the JWT generator from Stream's documentation.

Go to Stream's Token Generator:
- Visit: https://getstream.io/chat/docs/react/token_generator/
Generate token for "alice":
- Enter your Stream Secret Key in the "Your Secret" field
- Enter alice in the "User ID" field
- Leave "Set Expiration?" unchecked for tokens that don't expire
- Click generate to get Alice's token
Generate token for "bob":
- Keep the same Stream Secret Key
- Change User ID to bob
- Click generate to get Bob's token
Copy both tokens - you'll use these in your environment variables

Why These Specific User IDs?

Your React code determines the user based on email:

const isAlice = user.primaryEmailAddress?.emailAddress === "alice@example.com";
const streamUserId = isAlice ? STREAM_USER_ID_ALICE : STREAM_USER_ID_BOB;

If the logged-in user's email is alice@example.com, it uses the "alice" user ID
For any other email, it uses the "bob" user ID

So you need tokens specifically for:

User ID: alice
User ID: bob

🔐 Step 4: Environment Variables

Create a .env file in your project root with the following variables:

VITE_CLERK_PUBLISHABLE_KEY=your_clerk_publishable_key_here
VITE_STREAM_API_KEY=your_stream_api_key_here
VITE_STREAM_USER_ID_ALICE=alice
VITE_STREAM_USER_TOKEN_ALICE=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoiYWxpY2UifQ.generated_token_here
VITE_STREAM_USER_ID_BOB=bob
VITE_STREAM_USER_TOKEN_BOB=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoiYm9iIn0.generated_token_here

Replace the token values with the ones you generated using your Stream secret key.

⚠️ Important Security Notes:

Never commit your .env file to version control
Add .env to your .gitignore file
Keep your Stream Secret Key secure and never expose it in client-side code
The tokens shown above are examples - use your own generated tokens
Replace all example values with your actual credentials

📁 Step 5: Add Your Application Files

1. Create `src/App.jsx`

import React, { useEffect, useState } from "react";
import "./appli.css";
import 'stream-chat-react/dist/css/v2/index.css'; 

import {
  useUser,
  SignedIn,
  SignedOut,
  SignInButton,
  UserButton,
} from "@clerk/clerk-react";
import { StreamChat } from "stream-chat";
import {
  Chat,
  Channel,
  ChannelHeader,
  MessageList,
  MessageInput,
  ChannelList,
  Window, 
} from "stream-chat-react";

const STREAM_API_KEY = import.meta.env.VITE_STREAM_API_KEY;
const STREAM_USER_ID_ALICE = import.meta.env.VITE_STREAM_USER_ID_ALICE;
const STREAM_USER_TOKEN_ALICE = import.meta.env.VITE_STREAM_USER_TOKEN_ALICE;
const STREAM_USER_ID_BOB = import.meta.env.VITE_STREAM_USER_ID_BOB;
const STREAM_USER_TOKEN_BOB = import.meta.env.VITE_STREAM_USER_TOKEN_BOB;


export default function App() {
  const { user, isLoaded } = useUser();
  const [chatClient, setChatClient] = useState(null);

  useEffect(() => {
    if (!isLoaded || !user) return;

    const client = StreamChat.getInstance(STREAM_API_KEY);

    const isAlice = user.primaryEmailAddress?.emailAddress === "alice@example.com";
    const streamUserId = isAlice ? STREAM_USER_ID_ALICE : STREAM_USER_ID_BOB;
    const streamToken = isAlice ? STREAM_USER_TOKEN_ALICE : STREAM_USER_TOKEN_BOB;

    if (client.userID !== streamUserId) {
        client.connectUser(
            { id: streamUserId, name: user.fullName || streamUserId, image: user.imageUrl },
            streamToken
        ).then(() => {
            setChatClient(client);
        });
    }


    return () => {
        client.disconnectUser().then(() => {
            setChatClient(null);
        });
    };
  }, [isLoaded, user]);

  const generalChannel = chatClient?.channel("messaging", "general", {
    name: "General Chat",
    members: [STREAM_USER_ID_ALICE, STREAM_USER_ID_BOB],
  });


  useEffect(() => {
    if (generalChannel) generalChannel.watch();
  }, [generalChannel])


  if (!isLoaded) {
    return <div className="loading-screen">🔄 Loading authentication...</div>;
  }

  return (
    <>
      <SignedOut>
        <div className="signed-out-container">
          <h2>🚀 Welcome to My Chat App</h2>
          <p>Please sign in to start chatting</p>
          <SignInButton mode="modal">
            <button className="sign-in-button">Sign In / Sign Up</button>
          </SignInButton>
        </div>
      </SignedOut>

      <SignedIn>
        <AppHeader />
        {!chatClient || !generalChannel ? (
            <div className="loading-screen">🔄 Connecting to chat...</div>
        ) : (
          <Chat client={chatClient} theme="messaging light">
            <ChannelList sort={{ last_message_at: -1 }} />
            <Channel channel={generalChannel}>
              <Window>
                <ChannelHeader />
                <MessageList />
                <MessageInput />
              </Window>
            </Channel>
          </Chat>
        )}
      </SignedIn>
    </>
  );
}

const AppHeader = () => (
  <header className="app-header">
    <h1>🚀 My Chat App</h1>
    <UserButton afterSignOutUrl="/" />
  </header>
);

2. Create `src/appli.css`

/* Basic Layout & Centering */
.loading-screen,
.signed-out-container {
  display: flex;
  flex-direction: column;
  justify-content: center;
  align-items: center;
  height: 100vh;
  font-family: sans-serif;
}

.sign-in-button {
  padding: 12px 24px;
  margin-top: 20px;
  font-size: 16px;
  cursor: pointer;
  border-radius: 6px;
  border: none;
  background-color: #005fff;
  color: #fff;
  font-weight: bold;
}

/* Header Styling */
.app-header {
  padding: 10px 20px;
  background: #f5f5f5;
  display: flex;
  justify-content: space-between;
  align-items: center;
  border-bottom: 1px solid #e0e0e0;
}

.app-header h1 {
  font-size: 1.5em;
}

/* This makes the Stream Chat component fill the remaining screen height */
.str-chat__container {
  height: calc(100vh - 65px); /* 100vh minus the header height */
}

🚀 Step 6: Run Your Application

Start the development server:

   npm run dev

Open your browser and navigate to:

   http://localhost:5173

🎯 How It Works

Authentication Flow

Signed Out State: Users see a welcome screen with a "Sign In" button
Sign In Process: Clicking the button opens Clerk's authentication modal
Signed In State: Authenticated users can access the chat interface

Chat System

User Detection: The app determines if the signed-in user is Alice or Bob based on their email
Stream Connection: Connects to Stream Chat using the appropriate user credentials
Real-time Messaging: Users can send and receive messages in real-time

👥 Testing Your App

To test the chat functionality:

Set up test users in Clerk:
- Create two test accounts with emails: alice@example.com and any other email for Bob
Test the chat:
- Sign in as Alice in one browser/tab
- Sign in as Bob in another browser/tab (incognito mode)
- Start chatting between the two users

🔍 Troubleshooting

Common Issues and Solutions

1. Environment Variables Not Loading

Make sure your .env file is in the project root
Restart your development server after adding environment variables
Check that variable names start with VITE_

2. Clerk Authentication Not Working

Verify your Clerk publishable key is correct
Check that ClerkProvider is properly wrapping your App component

3. Stream Chat Connection Issues

Ensure your Stream API key is valid
Verify user tokens are correctly generated for Alice and Bob
Check browser console for connection errors

🔐 Security Notes

For Production:

Never expose user tokens in client-side code
Implement server-side token generation
Use environment variables for all sensitive data

Current Setup Limitations:

This is a development setup with hardcoded user tokens
Suitable for learning and testing purposes only
Not recommended for production use

📚 Next Steps

Once your basic chat is working, consider:

Improved Authentication:
- Dynamic user creation
- Server-side token generation
- Role-based access control

Happy Chatting! 🎉

Diabetes Detection On AWS

Naman — Sun, 10 Aug 2025 14:57:36 +0000

Diabetes Detection on AWS — Step-by-Step Complete Guide

A practical, step-by-step walkthrough to build a production-ready Diabetes Prediction web app using AWS services. Manual setup through AWS Console with code files for EC2 deployment.

TL;DR (One-line)

Train a scikit-learn model locally → upload to S3 via console → create SNS topic & DynamoDB table via console → host Flask API on EC2 that loads model from S3, predicts & stores results → expose via API Gateway → host frontend with AWS Amplify.

GitHub reference: https://github.com/naman-0804/Diabetes_Prediction_onAWS

Architecture Overview

Local Training — Train model locally with scikit-learn
S3 — Store model file (modelaws.joblib)
EC2 + Flask — Backend API server
DynamoDB — Store prediction results
SNS — Email notifications to users
API Gateway — Secure, managed public endpoint
Amplify — Frontend hosting

Prerequisites

AWS account with permissions
Python 3.8+ locally
WinSCP for file transfer to EC2: https://winscp.net/eng/download.php
PuTTY for SSH access
Basic knowledge of Flask and AWS console

Manual Setup Steps

Step 1 — Train Model Locally

Create train.py:

# train.py - Train diabetes prediction model
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
import joblib

# Load dataset (download from Kaggle: Pima Indian Diabetes Dataset)
df = pd.read_csv('diabetes.csv')

X = df.drop('Outcome', axis=1)
y = df['Outcome']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Save model
joblib.dump(model, 'modelaws.joblib')
print("Model saved as modelaws.joblib")

# Test accuracy
accuracy = model.score(X_test, y_test)
print(f"Model accuracy: {accuracy:.2f}")

Run locally:

python train.py

This creates modelaws.joblib file.

Step 2 — Manual AWS Console Setup

2.1 Create S3 Bucket

Go to AWS Console → S3
Click "Create bucket"
Choose unique bucket name (e.g., your-diabetes-model-bucket)
Select your region (e.g., us-east-1)
Keep default settings, click "Create bucket"
Upload modelaws.joblib to this bucket

2.2 Create SNS Topic

Go to AWS Console → SNS
Click "Create topic"
Choose "Standard" type
Name: diabetes-predictions
Click "Create topic"
Copy the Topic ARN (you'll need this)
Click "Create subscription"
Protocol: Email
Endpoint: your email address
Check your email and confirm subscription

2.3 Create DynamoDB Table

Go to AWS Console → DynamoDB
Click "Create table"
Table name: DiabetesPredictions
Partition key: email (String)
Sort key: timestamp (String)
Use default settings
Click "Create table"

2.4 Create IAM Role for EC2

Go to AWS Console → IAM
Click "Roles" → "Create role"
Select "AWS service" → "EC2"
Click "Next"
Create custom policy with this JSON:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject"],
      "Resource": ["arn:aws:s3:::your-diabetes-model-bucket/*"]
    },
    {
      "Effect": "Allow",
      "Action": ["sns:Publish", "sns:Subscribe", "sns:ListSubscriptionsByTopic"],
      "Resource": ["arn:aws:sns:us-east-1:YOUR-ACCOUNT-ID:diabetes-predictions"]
    },
    {
      "Effect": "Allow",
      "Action": ["dynamodb:PutItem", "dynamodb:UpdateItem", "dynamodb:GetItem"],
      "Resource": ["arn:aws:dynamodb:us-east-1:YOUR-ACCOUNT-ID:table/DiabetesPredictions"]
    }
  ]
}

Name the role: diabetes-ec2-role
Click "Create role"

Step 3 — Launch EC2 Instance

Go to AWS Console → EC2
Click "Launch instance"
Choose "Amazon Linux 2 AMI"
Instance type: t2.micro (free tier)
Important: In "Advanced details" → "IAM instance profile" → select diabetes-ec2-role
Security Group settings:
- SSH (22) from your IP
- HTTP (80) from anywhere
- Custom TCP (5000) from anywhere (for testing)
Create/use existing key pair
Launch instance

Step 4 — Code Files to Upload

Create these files on your local machine:

backend.py

import json
import boto3
import pandas as pd
import joblib
from flask import Flask, request, jsonify
from flask_cors import CORS
from datetime import datetime

app = Flask(__name__)
CORS(app)

# Configuration - UPDATE THESE VALUES
BUCKET_NAME = 'your-diabetes-model-bucket'  # Your S3 bucket name
MODEL_KEY = 'modelaws.joblib'  # Your model file name in S3
SNS_TOPIC_ARN = 'arn:aws:sns:us-east-1:YOUR-ACCOUNT-ID:diabetes-predictions'  # Your SNS topic ARN
DYNAMODB_TABLE_NAME = 'DiabetesPredictions'  # Your DynamoDB table name
AWS_REGION = 'us-east-1'  # Your AWS region

# Initialize AWS clients
s3 = boto3.client('s3', region_name=AWS_REGION)
sns_client = boto3.client('sns', region_name=AWS_REGION)
dynamodb = boto3.resource('dynamodb', region_name=AWS_REGION)
table = dynamodb.Table(DYNAMODB_TABLE_NAME)

# Download and load the model when the server starts
model = None
download_path = '/tmp/modelaws.joblib'

try:
    s3.download_file(BUCKET_NAME, MODEL_KEY, download_path)
    model = joblib.load(download_path)
    print("Model loaded successfully from S3")
except Exception as e:
    print(f"Error loading model: {str(e)}")

@app.route('/', methods=['GET'])
def health_check():
    return jsonify({'status': 'API is live'})

@app.route('/predict', methods=['POST'])
def predict():
    if not model:
        return jsonify({'error': 'Model could not be loaded'}), 500

    try:
        # Get JSON data from the request
        data = request.get_json()
        if not data:
            return jsonify({'error': 'Invalid or missing JSON data'}), 400

        email = data.get('email')
        if not email:
            return jsonify({'error': 'Email is required'}), 400

        # Extract input data with defaults
        pregnancies = int(data.get('Pregnancies', 0))
        glucose = int(data.get('Glucose', 0))
        blood_pressure = int(data.get('BloodPressure', 0))
        skin_thickness = int(data.get('SkinThickness', 0))
        insulin = int(data.get('Insulin', 0))
        bmi = float(data.get('BMI', 0.0))
        pedigree = float(data.get('DiabetesPedigreeFunction', 0.0))
        age = int(data.get('Age', 0))

        # Check if email is already subscribed to SNS
        try:
            response = sns_client.list_subscriptions_by_topic(TopicArn=SNS_TOPIC_ARN)
            subscriptions = response.get('Subscriptions', [])
            if not any(sub['Endpoint'] == email for sub in subscriptions):
                sns_client.subscribe(
                    TopicArn=SNS_TOPIC_ARN,
                    Protocol='email',
                    Endpoint=email
                )
        except Exception as e:
            print(f"Error subscribing email: {e}")

        # Prepare input data for prediction
        input_data = [[pregnancies, glucose, blood_pressure, skin_thickness,
                       insulin, bmi, pedigree, age]]
        input_df = pd.DataFrame(input_data, columns=[
            'Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness',
            'Insulin', 'BMI', 'DiabetesPedigreeFunction', 'Age'
        ])

        # Make prediction
        prediction = model.predict(input_df)
        predicted_label = int(prediction[0])

        # Send SNS notification
        message = f"Diabetes Prediction Result: {predicted_label}"
        try:
            sns_client.publish(
                TopicArn=SNS_TOPIC_ARN,
                Message=message,
                Subject='Diabetes Prediction Result'
            )
        except Exception as e:
            print(f"Error sending SNS: {e}")

        # Store result in DynamoDB
        result_data = {
            'email': email,
            'timestamp': datetime.utcnow().isoformat(),
            'Pregnancies': pregnancies,
            'Glucose': glucose,
            'BloodPressure': blood_pressure,
            'SkinThickness': skin_thickness,
            'Insulin': insulin,
            'BMI': bmi,
            'DiabetesPedigreeFunction': pedigree,
            'Age': age,
            'PredictedOutcome': predicted_label
        }

        try:
            table.put_item(Item=result_data)
        except Exception as e:
            print(f"Error storing in DynamoDB: {e}")

        return jsonify({'Predicted Label': predicted_label})

    except Exception as e:
        print(f"Error in prediction: {str(e)}")
        return jsonify({'error': str(e)}), 400

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=False)

requirements.txt

flask==2.3.3
flask-cors==4.0.0
boto3==1.28.57
pandas==2.1.1
scikit-learn==1.3.0
joblib==1.3.2
gunicorn==21.2.0

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Diabetes Prediction</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }

        body {
            font-family: 'Arial', sans-serif;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            min-height: 100vh;
            display: flex;
            justify-content: center;
            align-items: center;
        }

        .container {
            background: white;
            padding: 2rem;
            border-radius: 15px;
            box-shadow: 0 20px 40px rgba(0,0,0,0.1);
            width: 100%;
            max-width: 500px;
        }

        h2 {
            text-align: center;
            color: #333;
            margin-bottom: 2rem;
            font-size: 2rem;
        }

        .input-container {
            margin-bottom: 1rem;
        }

        label {
            display: block;
            margin-bottom: 0.5rem;
            color: #555;
            font-weight: bold;
        }

        input {
            width: 100%;
            padding: 12px;
            border: 2px solid #ddd;
            border-radius: 8px;
            font-size: 16px;
            transition: border-color 0.3s;
        }

        input:focus {
            outline: none;
            border-color: #667eea;
        }

        button {
            width: 100%;
            padding: 15px;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            color: white;
            border: none;
            border-radius: 8px;
            font-size: 18px;
            font-weight: bold;
            cursor: pointer;
            transition: transform 0.2s;
            margin-top: 1rem;
        }

        button:hover {
            transform: translateY(-2px);
        }

        #result {
            margin-top: 2rem;
            padding: 1rem;
            border-radius: 8px;
            text-align: center;
            font-weight: bold;
            min-height: 50px;
            display: flex;
            align-items: center;
            justify-content: center;
        }

        .success {
            background-color: #d4edda;
            color: #155724;
            border: 1px solid #c3e6cb;
        }

        .error {
            background-color: #f8d7da;
            color: #721c24;
            border: 1px solid #f5c6cb;
        }
    </style>
</head>
<body>

    <div class="container">
        <h2>🩺 Diabetes Prediction</h2>
        <form id="predictionForm">
            <div class="input-container">
                <label for="email">📧 Email:</label>
                <input type="email" id="email" placeholder="Enter your email" required>
            </div>

            <div class="input-container">
                <label for="Pregnancies">🤱 Pregnancies:</label>
                <input type="number" id="Pregnancies" placeholder="Enter number of pregnancies" required min="0">
            </div>

            <div class="input-container">
                <label for="Glucose">🍬 Glucose Level:</label>
                <input type="number" id="Glucose" placeholder="Enter glucose level (mg/dL)" required min="0">
            </div>

            <div class="input-container">
                <label for="BloodPressure">💓 Blood Pressure:</label>
                <input type="number" id="BloodPressure" placeholder="Enter blood pressure (mmHg)" required min="0">
            </div>

            <div class="input-container">
                <label for="SkinThickness">📏 Skin Thickness:</label>
                <input type="number" id="SkinThickness" placeholder="Enter skin thickness (mm)" required min="0">
            </div>

            <div class="input-container">
                <label for="Insulin">💉 Insulin Level:</label>
                <input type="number" id="Insulin" placeholder="Enter insulin level (μU/mL)" required min="0">
            </div>

            <div class="input-container">
                <label for="BMI">⚖️ BMI:</label>
                <input type="number" step="0.1" id="BMI" placeholder="Enter BMI (kg/m²)" required min="0">
            </div>

            <div class="input-container">
                <label for="DiabetesPedigreeFunction">🧬 Diabetes Pedigree Function:</label>
                <input type="number" step="0.01" id="DiabetesPedigreeFunction" placeholder="Enter DPF (0.0 - 2.5)" required min="0" max="2.5">
            </div>

            <div class="input-container">
                <label for="Age">🎂 Age:</label>
                <input type="number" id="Age" placeholder="Enter age in years" required min="1" max="120">
            </div>

            <button type="button" onclick="submitData()">🔮 Get Prediction</button>
        </form>
        <div id="result"></div>
    </div>

    <script>
        function submitData() {
            const resultElement = document.getElementById("result");
            resultElement.innerText = "🔄 Processing your prediction...";
            resultElement.className = "";

            const data = {
                email: document.getElementById("email").value,
                Pregnancies: Number(document.getElementById("Pregnancies").value),
                Glucose: Number(document.getElementById("Glucose").value),
                BloodPressure: Number(document.getElementById("BloodPressure").value),
                SkinThickness: Number(document.getElementById("SkinThickness").value),
                Insulin: Number(document.getElementById("Insulin").value),
                BMI: parseFloat(document.getElementById("BMI").value),
                DiabetesPedigreeFunction: parseFloat(document.getElementById("DiabetesPedigreeFunction").value),
                Age: Number(document.getElementById("Age").value),
            };

            // Update this URL to your API Gateway endpoint or EC2 public IP
            const API_URL = 'http://YOUR-EC2-PUBLIC-IP:5000/predict';

            fetch(API_URL, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify(data)
            })
            .then(response => {
                if (!response.ok) {
                    throw new Error('Network response was not ok: ' + response.statusText);
                }
                return response.json();
            })
            .then(result => {
                const prediction = result['Predicted Label'];
                const message = prediction === 1 
                    ? '⚠️ Higher risk detected. Please consult a healthcare professional.' 
                    : '✅ Lower risk detected. Continue maintaining a healthy lifestyle.';

                resultElement.innerHTML = `
                    <strong>Prediction Result: ${prediction}</strong><br>
                    ${message}<br>
                    📧 A detailed report has been sent to your email.
                `;
                resultElement.classList.add(prediction === 1 ? "error" : "success");
            })
            .catch(error => {
                console.error('Error:', error);
                resultElement.innerText = '❌ Error: ' + error.message;
                resultElement.classList.add("error");
            });
        }
    </script>
</body>
</html>

Step 5 — Deploy to EC2

5.1 Connect to EC2

Use PuTTY to connect to your EC2 instance
Use the .ppk key file and EC2 public IP

5.2 Prepare EC2 Environment

# Update system
sudo yum update -y

# Install Python 3 and pip
sudo yum install -y python3 python3-pip

# Create app directory
mkdir ~/app
cd ~/app

# Create virtual environment
python3 -m venv venv
source venv/bin/activate

# Update pip
pip install --upgrade pip

5.3 Upload Files using WinSCP

Open WinSCP
Connect to your EC2 instance using .ppk key
Upload these files to /home/ec2-user/app/:
- backend.py
- requirements.txt
- index.html

5.4 Install Dependencies and Run

# Navigate to app directory
cd ~/app
source venv/bin/activate

# Install requirements
pip install -r requirements.txt

# Update backend.py with your actual values:
# - BUCKET_NAME
# - SNS_TOPIC_ARN (from Step 2.2)
# - AWS region and account ID

# Run the application
python backend.py

Step 6 — Create API Gateway (Optional)

Go to AWS Console → API Gateway
Create REST API
Create resource /predict
Create POST method
Integration type: HTTP
Endpoint URL: http://your-ec2-public-ip:5000/predict
Enable CORS
Deploy API
Update index.html with the API Gateway URL

Step 7 — Test Your Application

Test Backend Directly:

curl -X POST http://your-ec2-public-ip:5000/predict \
  -H "Content-Type: application/json" \
  -d '{
    "email": "test@example.com",
    "Pregnancies": 2,
    "Glucose": 120,
    "BloodPressure": 70,
    "SkinThickness": 20,
    "Insulin": 79,
    "BMI": 25.5,
    "DiabetesPedigreeFunction": 0.5,
    "Age": 33
  }'

Test Frontend:

Open index.html in browser
Fill out the form
Click "Get Prediction"
Check email for SNS notification
Check DynamoDB table for stored result

Step 8 — Deploy Frontend with Amplify

Create GitHub repository
Upload index.html to repository
Go to AWS Console → Amplify
Connect to GitHub
Deploy your repository

Troubleshooting

Common Issues:

Model not loading from S3
- Check bucket name and file name in backend.py
- Verify IAM role has S3 read permissions
SNS emails not received
- Check spam folder
- Confirm email subscription in SNS console
DynamoDB permission errors
- Verify IAM role has DynamoDB write permissions
- Check table name in backend.py
CORS errors
- Enable CORS in API Gateway
- Check flask-cors is installed
Connection refused errors
- Check EC2 security group allows port 5000
- Verify application is running on correct port

Files Summary

You need these 3 main files:

backend.py - Flask API server
requirements.txt - Python dependencies
index.html - Frontend form

Transfer to EC2 using WinSCP, install dependencies, update configuration values, and run!

Final Notes

Always use IAM roles instead of hardcoded AWS keys
Consider using Elastic IP for stable EC2 endpoint
Enable CloudWatch logging for monitoring
Use HTTPS in production with SSL certificate
Implement input validation and rate limiting for production use

This guide provides a complete manual setup process using AWS Console with minimal CLI usage. The architecture is production-ready and follows AWS best practices.

Secure, Login-Free File Transfers with File_Storage

Naman — Sun, 10 Aug 2025 07:35:28 +0000

Secure, Login-Free File Transfers with File_Storage

Ever been stuck on a public lab computer and needed to get your files to your own device—without logging into your email, Google Drive, or Dropbox?

That’s exactly why I built File_Storage — a lightweight, PIN-protected web app for quick, secure file transfers.

Why File_Storage Exists

When working in shared environments like college computer labs or public workstations, logging into personal accounts can feel risky.

I wanted a solution that:

Works without sign-ups or logins
Protects files from unwanted access
Is easy enough for anyone to use in under 10 seconds

What It Does

With File_Storage, you can:

Upload any number of files to a secure online folder
Download them later from any device
Delete files instantly when you’re done

All through a clean, responsive web interface — no accounts, just a PIN.

How It Works

1. Secure Backend

Google Drive API handles storage, powered by a dedicated Service Account
No credentials in the code — everything is stored in environment variables
A simple PIN system ensures only authorized users can access the interface

2. User Flow

Enter the access PIN
Upload files (single or multiple)
Download instantly, or delete when no longer needed

Tech Stack

Backend: Flask (Python), Google Drive API
Frontend: HTML, CSS, JavaScript (AJAX for smooth uploads/deletes)
Security: Service Account keys via environment variables, no password storage
Hosting: Cloud platform (e.g., Render)

Deploy Your Own

Want to run your own instance?

Create a Google Cloud project and enable the Drive API
Make a Service Account, generate a JSON key, share your Drive folder with it
Deploy the Flask app to a cloud host
Set the GOOGLE_APPLICATION_CREDENTIALS_JSON environment variable

(Full setup guide in the GitHub README)

Who Should Use It

Students & Teachers — Move files without touching your email
Teams — Quick, private file drops without a complex sharing setup
Anyone — Needing simple, secure file transfer in seconds

Final Thoughts

File_Storage turns file transfer from a tedious task into a fast, private, login-free process.

Whether you’re working in a lab, at a library, or on a friend’s laptop, your files are just a PIN away.

🔗 View File_Storage on GitHub

Forem: Naman

📊 Extracting DSA Question Statistics from Codolio and TakeUForward (TUF)

🎯 What We're Building

🔍 Step 1: Reverse Engineering the APIs

1.1 Finding the Codolio API

1.2 Finding the TakeUForward API

1.3 Finding the GitHub Stats API (via Codolio)

🛠️ Step 2: Understanding the Data Structures

2.1 Codolio Response (DSA Stats)

2.2 TakeUForward Response

2.3 GitHub Response (via Codolio)

💻 Step 3: Writing the Complete Aggregator Script

3.1 Install Required Package

3.2 The Complete Script

3.3 Replace Placeholders

📤 Step 4: Run the Script

🔄 Step 5: Automate with GitHub Actions

Add GitHub Secrets

🎯 Conclusion

Mall Customer Segmentation using ML — A Step-by-Step Tutorial

🧠 Introduction

📊 Dataset Overview

⚙️ Step 1: Import Required Libraries

🧹 Step 2: Load and Preprocess Data

🧩 Step 3: Feature Scaling

🌀 Step 4: KMeans Clustering

📈 Step 5: Visualize Clusters

🧮 Step 6: Predicting Spending Score (Regression)

🌐 Step 7: Streamlit App for Deployment

🪄 Step 8: Run the Streamlit App

🎯 Conclusion

What You Learned

Build a Secure, Real-Time Chat App in Minutes with React, Clerk, and Stream

🚀 Chat Application Setup Guide

📋 Prerequisites

🏗️ Project Structure

🔧 Step 1: Initialize Your React Project

🔑 Step 2: Set Up Authentication (Clerk)

Create a Clerk Account

Configure Clerk in Your App

💬 Step 3: Set Up Chat (Stream)

Create a Stream Account

Generate User Tokens Manually

Using Stream's JWT Generator

Why These Specific User IDs?

🔐 Step 4: Environment Variables

📁 Step 5: Add Your Application Files

1. Create src/App.jsx

2. Create src/appli.css

🚀 Step 6: Run Your Application

🎯 How It Works

Authentication Flow

Chat System

👥 Testing Your App

🔍 Troubleshooting

Common Issues and Solutions

🔐 Security Notes

📚 Next Steps

Diabetes Detection On AWS

Diabetes Detection on AWS — Step-by-Step Complete Guide

TL;DR (One-line)

Architecture Overview

Prerequisites

Manual Setup Steps

Step 1 — Train Model Locally

Step 2 — Manual AWS Console Setup

2.1 Create S3 Bucket

2.2 Create SNS Topic

2.3 Create DynamoDB Table

2.4 Create IAM Role for EC2

Step 3 — Launch EC2 Instance

Step 4 — Code Files to Upload

backend.py

requirements.txt

index.html

Step 5 — Deploy to EC2

5.1 Connect to EC2

5.2 Prepare EC2 Environment

5.3 Upload Files using WinSCP

5.4 Install Dependencies and Run

1. Create `src/App.jsx`

2. Create `src/appli.css`