I Built an "Ethical" GitHub Streak Guardian (And How I Survived API Rate Limits)

Devanshu P. — Sat, 22 Nov 2025 21:01:17 +0000

We’ve all been there. You’re deep in the zone, debugging a race condition or refactoring a messy component. You code for 8 hours straight. You close your laptop, exhausted but proud.

The next morning, you check your GitHub profile and see... a gray square.

You forgot to push. Your 100-day streak is gone. 📉

I built DailyDiff to solve this. But I didn't want to build just another "fake commit bot" that spams update readme 50 times a day. I wanted to build a productivity companion that respects the spirit of open source while protecting your consistency.

Here is a deep dive into how I built a full-stack, timezone-aware automation tool using React, Node.js, Supabase, and the GitHub GraphQL API.

💡 The Core Concept: Ethical Automation

Most streak savers are simple scripts that push empty commits. DailyDiff is different. It offers Content Strategies:

Learning Logs: It can append what you learned that day to a repo.
Micro-Tasks: Stuck in "coder's block"? It suggests real tasks (like "Refactor variable names" or "Add JSDoc") to unblock you.
Timezone Intelligence: It knows your day isn't over until it's midnight in your city, not UTC.

🛠 The Tech Stack

I chose a distributed architecture to keep the frontend fast and the backend persistent.

Frontend: React (Vite) + Tailwind CSS (deployed on Vercel).
Backend: Node.js + Express (deployed on Render).
Database: Supabase (PostgreSQL) for storing user schedules and OAuth tokens.
Automation: node-cron for background job scheduling.
Auth: GitHub OAuth 2.0.

🧠 Technical Deep Dive: The "Minor" Details That Matter

Building a CRUD app is easy. Building a system that runs reliably in the background on free-tier infrastructure is where it gets interesting. Here are the three biggest engineering challenges I solved.

1. The "Sleeping Server" Problem

I deployed the backend to Render's Free Tier. It’s great, but it has a catch: it spins down after 15 minutes of inactivity.

If my server is asleep, the Cron job responsible for checking commit schedules (cron.schedule('* * * * *')) dies.

The Solution: The Heartbeat Route
I added a lightweight health-check endpoint in Express:

// server/index.js
app.get('/', (req, res) => {
  res.status(200).send('✅ DailyDiff Backend is Active');
});

Then, I set up an external monitor (using cron-job.org) to ping this route every 14 minutes. This keeps the Render instance "warm" 24/7 without costing a dime, ensuring user automations never miss a beat.

2. Solving GitHub API Rate Limits (The Hybrid Cache)

DailyDiff visualizes your contribution history using a beautiful heatmap. To render this, I fetch data using GitHub's GraphQL API.

The problem? fetching a year's worth of contribution data is expensive. During development (thanks to React Strict Mode double-invoking useEffect), I hit GitHub's 5,000 req/hour limit constantly.

The Solution: A Hybrid Caching Strategy

I implemented a two-layer cache to protect my API quota:

Layer 1: Client-Side (LocalStorage)
Before the frontend even talks to the server, it checks localStorage. If valid data exists (less than 1 hour old), it renders instantly. 0ms latency, 0 API calls.
Layer 2: Server-Side (Disk Cache)
If the client cache misses, the request hits the server. The server checks a local JSON file (cache_contributions.json). Even though Render has an ephemeral filesystem, this disk cache survives brief restarts and prevents the "thundering herd" problem if multiple clients connect simultaneously.

// Code snippet from my caching logic
const cachedRaw = localStorage.getItem(CACHE_KEY);
if (cachedRaw) {
    const { timestamp, data } = JSON.parse(cachedRaw);
    const age = Date.now() - timestamp;
    if (age < CACHE_DURATION) {
        return data; // Return early!
    }
}

3. Timezone-Aware Cron Jobs

Servers run on UTC. Users do not.
If a user in India (IST) sets a reminder for 11:00 PM, but my server is in Oregon (UTC-7), a standard cron job fails.

I couldn't just store 23:00 in the database. I had to store the user's Timezone (Asia/Kolkata) alongside the time.

In the backend cron loop, I don't check if ServerTime == UserTime. instead, I dynamically convert the server's now() into the user's local time before comparing:

// Inside the Cron Loop
const userTimeString = new Date().toLocaleTimeString('en-US', {
  timeZone: job.timezone, // e.g., 'Asia/Kolkata'
  hour: '2-digit', 
  minute: '2-digit',
  hour12: false
});

if (userTimeString === job.schedule_time) {
   // Fire the commit!
}

This ensures that 8:00 PM feels like 8:00 PM, no matter where the server is located.

🎨 UI/UX: The "GitHub Dark Mode" Aesthetic

I wanted the app to feel native to the developer ecosystem. I utilized Tailwind CSS to mirror GitHub's specific dark mode color palette (#0d1117 for background, #39d353 for success states).

I also implemented a React Portal for the tooltips on the activity graph. Because the graph is in a container with overflow-x: auto (for scrolling), a standard absolute tooltip would get clipped. Portaling it to document.body allows it to float freely above the UI.

🚀 Deployment & Security

Deploying a separated frontend and backend required strict CORS and Cookie configuration.

Since the frontend (vercel.app) and backend (onrender.com) are on different domains, I had to set the session cookies to SameSite: none and Secure: true.

app.use(cookieSession({
  name: 'session',
  keys: [process.env.SESSION_SECRET],
  // Required for cross-site cookies between Vercel and Render
  sameSite: process.env.NODE_ENV === 'production' ? 'none' : 'lax',
  secure: process.env.NODE_ENV === 'production', 
  httpOnly: true
}));

🔮 What's Next?

DailyDiff is currently in v1. I'm planning to add:

AI-Generated Commit Content: Using OpenAI to read the user's actual code changes and suggest commit messages.
Team Leaderboards: Gamifying the streak experience.

🔗 Links

This project is fully open-source. I’d love for you to check out the code, fork it, or give it a star if you find it useful!

Live Demo: https://daily-diff.vercel.app/
GitHub Repo: https://github.com/KrDevanshu06/dailydiff Star it.🌟

Thanks for reading! Let me know in the comments—have you ever lost a 100+ day streak? 😅

Career Companion: A GenAI-Powered Assistant for College Students

Devanshu P. — Sun, 20 Apr 2025 13:44:55 +0000

🎓 Career Companion is an interactive GenAI-powered assistant designed to help college students with personalized career guidance, course suggestions, and tech pathway insights — all powered by cutting-edge generative AI tools and hosted on Kaggle Notebooks.

🚀 Project Overview

As part of my Generative AI Capstone Project, I built a Career Companion Assistant that simulates interactive Q&A sessions for college students, helping them explore the right career choices and resources in real-time using Large Language Models (LLMs).

The assistant supports both chat-based interaction and form-driven recommendations, making it beginner-friendly and effective even without real-time UI deployment.

🧠 Key GenAI Capabilities Demonstrated

This project integrates three core GenAI capabilities:

✅ 1. Few-shot Prompting

The assistant uses prompt engineering to provide consistent responses with career suggestions, even for ambiguous or brief questions.
Includes career role templates (e.g., software engineer, data analyst, cloud engineer) with predefined suggestions and courses.

✅ 2. Structured Output (Controlled Generation)

Responses are formatted in a consistent, structured way (lists, markdown tables, and sections).
Useful for logging into CSV files and analyzing student needs.

✅ 3. Retrieval Augmented Generation (RAG)

Simulated document lookup and embeddings are used to enrich the assistant's answers.
Students can get domain-specific insights like tech stacks, roadmap links, and certifications.

🧰 Tools & Technologies Used

🧠 Gemini Pro (via API) – for LLM-based Q&A
🐍 Python & Pandas – for backend logic and chat logging
📊 Kaggle Notebooks – as the main interactive environment
📄 CSV Export – to save Q&A logs for further analysis
🔗 Markdown display – to show responses in clean UI format

💡 How It Works (with Screenshots)

The project runs inside a Kaggle Notebook with the following components:

Model Initialization
- Sets up Gemini Pro API and context for responses.
Prompt Handling Function
- A function handles user prompts (dummy input block on Kaggle) and logs responses.
Response Generator
- Calls the model and uses prompt templates for consistent responses.
Chat Logging
- Stores every Q&A in a Pandas DataFrame and saves it as career_chat_log.csv.
Download Link
- Allows users to download the full session as a log file from Kaggle.

📷 Screenshots

Setup block with Gemini Pro key

Sample Q&A block in notebook

Downloadable log file

Structured response with markdown

🔍 Sample Output

🔗 Try the Project

You can view the full notebook here:

👉 Kaggle Notebook Link

📚 What I Learned

How to use LLMs with few-shot prompting
Creating structured logs for better analysis
Simulating interaction in a non-UI environment like Kaggle
Basics of Retrieval Augmented Generation (RAG)

🛠 Improvements Planned

Integrate embeddings using FAISS/ChromaDB
Use Streamlit or Gradio for web UI
Allow real-time user input with context memory

✅ GenAI Capabilities Recap

Capability	Used
✅ Structured Output	✅
✅ Few-shot Prompting	✅
✅ RAG	✅

🙌 Final Thoughts

GenAI isn't just about fancy chatbots — it can truly empower students by providing context-aware, structured, and actionable guidance. This project gave me real-world insight into building domain-specific assistants using the power of generative AI.

If you're a student looking to get into AI, education tech, or LLM apps — start experimenting today!

📬 Feel free to connect or ask questions in the comments!

LinkedIn
GitHub
Twitter
Kaggle

DEV Community: Devanshu P.