Forem: Sanjay Kumar Sah

BrewOps: A Production-Grade HTCPCP Dashboard

Sanjay Kumar Sah — Thu, 02 Apr 2026 11:40:36 +0000

This is a submission for the DEV April Fools Challenge

What I Built

I built BrewOps, a highly serious, production-grade DevOps dashboard for a delightfully useless protocol: the Hyper Text Coffee Pot Control Protocol (HTCPCP, RFC 2324).

Tired of walking to the breakroom only to find the coffee pot empty? BrewOps brings 1998's best internet joke into the modern era. It's a sleek control center that lets you monitor your network of coffee pots and teapots. You can issue BREW and PROPFIND requests, select your Accept-Additions (like Milk, Syrup, or Alcohol), and watch the live terminal logs.

And yes, if you try to brew coffee using the "Earl Grey Teapot" appliance, the server will correctly reject your request with a 418 I'm a teapot status code, complete with a panic animation.

Demo

Live App: BrewOps HTCPCP Dashboard

Code

Source Code: Google AI Studio Project

How I Built It

I built this using Next.js and Tailwind CSS to give it that authentic, dark-mode "serious developer tool" aesthetic. The icons are from lucide-react, and I used motion/react (Framer Motion) to create the smooth terminal log entries and the bouncing teapot animation when a 418 error is triggered.

The entire project was generated, iterated on, and deployed using Google AI Studio.

Prize Category

I am submitting this for two categories:

1. Best Ode to Larry Masinter:
This project is a literal, playable implementation of Larry Masinter's legendary RFC 2324. It faithfully recreates the HTCPCP headers (Accept-Additions, message/coffeepot content types) and intentionally triggers the famous 418 I'm a teapot error when you target the wrong appliance.

2. Best Google AI Usage:
I built this entire application from scratch using Google AI Studio (powered by Gemini 3.1 Pro). The AI agent helped me scaffold the Next.js app, design the Tailwind UI, write the simulated terminal logic, and instantly deploy the final build to Google Cloud Run (which is where it is currently hosted!).

Serenity: A Personal AI Wellbeing Companion Built with Google Gemini

Sanjay Kumar Sah — Tue, 03 Mar 2026 11:51:28 +0000

This is a submission for the Built with Google Gemini: Writing Challenge

What I Built with Google Gemini

I built Serenity, a comprehensive, privacy-first mental health and wellbeing application designed to act as your personal caretaker, health coach, and daily companion.

Mental health tools are often fragmented—you use one app for habit tracking, another for journaling, and yet another for meditation. Serenity solves this by combining all these tools into one cohesive, beautifully designed platform. It includes:

Mood Check-ins & Insights: Track daily emotional trends.
Daily Journal: A safe space for reflection.
Habit & Goal Tracker: Build positive routines and set long-term targets.
Wellness Hub: Interactive exercises including Box Breathing, 5-4-3-2-1 Grounding, Body Scan meditations, and Eye Strain Relief.

The Role of Google Gemini:
Google Gemini (gemini-3-flash-preview) acts as the core "brain" and empathetic heart of the app. Instead of just a generic chatbot, Serenity uses the @google/genai SDK to read your recent moods, incomplete habits, journal entries, and long-term goals as context.

Gemini provides highly tailored advice, health tips, and emotional support. For example, if you set a goal to "Run a 5K", you can click "Ask Serenity for a Plan", and Gemini will instantly generate a personalized diet, exercise, and lifestyle plan based on your current habits and mood history. It also proactively generates warm, encouraging reminders if you forget to complete your daily habits!

Demo

You can try out the live version of Serenity here:
🔗 Live Demo
🔗 Github Repo

(Note: The app is designed with a "Warm Organic" aesthetic using Tailwind CSS and Framer Motion to create a calming user experience.)

What I Learned

Building Serenity was an incredible learning experience:

Contextual AI Engineering: I learned how to effectively pass structured JSON data (user moods, habits, journals) into Gemini's system prompt to create an AI that truly "remembers" and understands the user's current state.
UI/UX for Mental Health: I learned the importance of color psychology and micro-interactions. Using glassmorphism, soft sage/earth tones, and smooth Framer Motion animations helped create a UI that actually lowers stress rather than adding to it.
Interactive Component Design: Building the Wellness Hub taught me how to manage complex state and timers in React, especially for the Body Scan and Eye Strain Relief exercises.

Google Gemini Feedback

What worked well:
The new @google/genai SDK is incredibly intuitive. The speed of the gemini-3-flash-preview model is phenomenal—it makes the conversational assistant feel truly real-time. I was also deeply impressed by how well Gemini understood the structured context I passed to it. It seamlessly connected the dots between a user feeling "anxious" in their mood log and suggesting the built-in grounding exercises.

Where I ran into friction:

The main challenge was prompt engineering to get the tone exactly right. Initially, the AI sounded a bit too clinical or robotic. I had to refine the system instructions heavily to ensure it consistently spoke with the warmth, empathy, and brevity of a "personal caretaker." Additionally, handling the multimodal inputs (allowing users to upload images to the chat) required some careful base64 encoding logic to pass to the API correctly, but once set up, it worked flawlessly.

Built with ❤️ for the Hack for Mental Health 2026 & DEV Challenge.

From Zero Rust to DevOps: Building a System Monitor with GitHub Copilot CLI

Sanjay Kumar Sah — Sun, 15 Feb 2026 06:34:12 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

I built rust-tui-dashboard, a terminal-based system monitor (similar to htop or btop) written entirely in Rust.

As a Full-Stack developer primarily experienced with JavaScript and the MERN stack, I have always wanted to learn Rust. However, the steep learning curve—specifically the borrow checker and strict type system—was intimidating. For this challenge, I decided to use the GitHub Copilot CLI as my "Senior Rust Engineer" to guide me through building a production-ready application from scratch.

Key Features:

Visual Gauges: Real-time CPU & Memory usage visualized with colorful progress bars (Cyan & Yellow).
Disk Alerts: Tracks partition usage (which hilariously warned me that my own drive is 97.5% full!).
Network Stats: Live upload/download speed tracking.
Cross-Platform: Runs on Linux, macOS, and Windows.
Automated Builds: A CI/CD pipeline set up via GitHub Actions.

Demo

Here is the final result running in my terminal:

Repository: rust-tui-dashboard

My Experience with GitHub Copilot CLI

Building this project was a journey of "Prompt -> Error -> Explanation -> Fix." The Copilot CLI didn't just write code for me; it taught me why the code worked (or didn't).

1. The "Hello World" Moment

I started with an empty folder and didn't even know the command to initialize a Rust project.
Prompt: how to initialize a new rust project named dev-dashboard
Result: It gave me cargo new dev-dashboard immediately. I was up and running in seconds.

2. Overcoming the "Generic" Hallucination

This was the most valuable interaction. I used the ratatui library for the UI, but the code Copilot initially suggested threw a complex compilation error:
error[E0107]: struct takes 0 generic arguments but 1 generic argument was supplied

Instead of pasting this into Google, I asked the CLI:

Prompt: struct takes 0 generic arguments but 1 generic argument was supplied

The Fix: Copilot correctly identified that the library version I installed had a breaking API change (Frame<B> became just Frame). It explained the difference, and while its initial code fix was slightly aggressive (it removed generics from everything), the explanation gave me enough context to manually fix the Terminal struct generics while simplifying the Frame struct. It turned a potential 2-hour debugging session into a 5-minute fix.

3. From Text to "Eye Candy"

Initially, my dashboard was just text blocks. I wanted it to look professional.

Prompt: "Update the ui function. Instead of displaying CPU Usage as simple text, use the ratatui::widgets::Gauge widget. Set the percent to app.cpu_usage and color it Cyan."

It instantly scaffolded the Gauge widget code, giving me professional-looking progress bars without me needing to read the entire documentation.

4. The DevOps Bonus

I didn't want users to have to compile the code themselves.

Prompt: "Create a GitHub Actions workflow file named .github/workflows/release.yml to build the project on push."

Copilot generated a perfect YAML file. Now, every time I push code, GitHub Actions automatically compiles my Rust binary and uploads it as an artifact.

Conclusion

The GitHub Copilot CLI bridged the gap between my JavaScript knowledge and Rust's strict environment. It allowed me to build a tool that I actually use now—if only to remind me to clean up my hard drive (seriously, only 7GB left!).

How I Improved Email Rendering Performance 15x Using Rust + WebAssembly (Next.js 16 Devlog)

Sanjay Kumar Sah — Fri, 13 Feb 2026 10:41:57 +0000

I decided to do something scary: Build a SaaS product in public, from scratch, sharing every win and every embarrassing error log along the way.

The product is Ansomail—an AI-powered drag-and-drop email editor.
The goal? To build a tool where Developers set the rules (Design System) and Marketers just drag-and-drop blocks, without ever breaking the layout.

Here is the unvarnished truth of my first week: battling the "bleeding edge" tax of Next.js 16, crashing my database, and eventually rewriting my engine in Rust for a 15x speed boost.

The Stack: Betting on Speed

I didn't want a legacy stack. I wanted speed.

Runtime: Bun (for instant startup)
Framework: Next.js 16 (Turbopack)
Monorepo: Turborepo (preparing for the Ansospace ecosystem)
Database: Postgres + Drizzle ORM
Linting: Biome (Farewell, ESLint)

It looked perfect on paper. Then I started coding.

Days 1-2: The Architecture & The "AI Architect"

The first challenge wasn't code; it was philosophy. How do you stop an AI from generating broken HTML?

Most AI builders treat LLMs like creative writers. I decided to treat them like Strict Architects. I set up a system where the AI's output is validated against a rigid JSON Schema. If the AI hallucinates a CSS class that doesn't exist in my system, the update is rejected before it ever hits the UI.

I also set up the "Hello World" of modern SaaS: An empty repo configured with Biome and Bun. It was clean, fast, and satisfying.

Days 3-4: The "Bleeding Edge" Tax

Then came the pain.

I hit what I call the "Bleeding Edge Tax." Next.js 16 and Bun are incredible, but they don't always play nice together. My dev server started crashing on hot reloads.

And then, I killed my database. 💀

I started getting the dreaded error:
FATAL: sorry, too many clients already

Because I'm using a serverless environment, every hot reload was opening a new connection to Postgres without closing the old one. My database choked.

The Fix: I had to implement strict Connection Pooling. It was a harsh reminder that "Serverless" doesn't mean "Ops-less." Once I capped the active connections, the backend stabilized, and I shipped the "My Templates" dashboard.

Days 5-6: Chasing the "Google Docs" Feel

With the backend stable, I moved to UX. I wanted a "Rename Template" feature that felt like Google Docs—instant.

I implemented Optimistic UI. When a user types, the UI updates immediately. The server validates it in the background. If it fails, we revert. If it works, the user never notices the lag.

// Detect dark theme var iframe = document.getElementById('tweet-2021209854837158185-500'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2021209854837158185&theme=dark" }

I also built the first version of the Rendering Engine:

DB stores JSON.
Parser converts JSON → MJML.
mjml-browser converts MJML → HTML.
Result renders in an iframe.

It worked. But it was slow. ~18ms per render. For a drag-and-drop tool, that felt sluggish.

Day 7: The Rust Rewrite (15x Speed Boost) 🚀

I couldn't settle for 18ms. I knew mjml-browser (Pure JS) was the bottleneck.

So, I did something drastic for a one-week-old project: I swapped the engine to Rust.

import { Engine, type ToHtmlResult } from "mrml";

const convertMJMLToHTML = (mjmlString: string) => {
  const engine = new Engine();
  const result = engine.toHtml(mjmlString);
  return result;
};

I integrated MRML (a Rust port of MJML) via WebAssembly.
The integration was tricky—Rust is strict. It refused to compile my "sloppy" JSON that JS had been happily ignoring. It forced me to fix my data structure.

But once it worked? The results were insane.

JS Engine: ~18ms
Rust (WASM): ~1.1ms

That is a 15x speed increase. The preview is now effectively real-time, running at 60fps.

What's Next?

Week 1 was about the Foundation. Week 2 is about the Interaction.

Now that I have a 1ms rendering engine, I'm building the actual Drag-and-Drop layer.

I'm documenting this entire journey daily on X (Twitter). If you're into Next.js, Rust, or just want to see a developer struggle and succeed in real-time, come say hi!

Follow the journey: #ansomail / @ansomail
Connect with me: x.com/sanjaysah101

Ansomail Devlog #1: Replacing JavaScript with Rust for 15x Faster Email Rendering (Next.js + WASM)

Sanjay Kumar Sah — Fri, 13 Feb 2026 05:46:06 +0000

Ansomail is an AI-powered drag-and-drop email builder I’m building in public. This week, I replaced its JavaScript rendering engine with Rust — and made it 15x faster.

I decided to do something scary: build a SaaS product in public, from scratch, sharing every win and every embarrassing error log along the way.

By Day 4, I had:

Crashed my database
Broken hot reload
Built an engine that felt painfully slow

By Day 7, I had:

Rewritten the rendering engine in Rust
Reduced render time from ~18ms → ~1.1ms (~15x faster)
Learned that “bleeding edge” stacks come with hidden costs

This is my Week 1 retrospective building Ansomail, an AI-powered drag-and-drop email editor.

The Goal: Building a High-Performance AI Email Builder

I’m building an email editor where:

Developers define the design system
Marketers drag-and-drop blocks
AI generates content — but never breaks layout

The constraint: The preview must feel like Google Docs. Instant.

Tech Stack: Next.js 16, Bun, Postgres & MJML

I deliberately chose a modern stack optimized for speed:

Runtime: Bun
Framework: Next.js 16 (Turbopack)
Monorepo: Turborepo
Database: Postgres + Drizzle ORM
Linting/Formatting: Biome
Initial Rendering Engine: mjml-browser

It looked perfect on paper.

Then reality happened.

Days 1–2: Enforcing AI Output with JSON Schema Validation

The first architectural decision wasn’t about performance.

It was about control.

Instead of letting the LLM freely generate HTML, I:

Forced output into a strict JSON Schema
Validated structure before rendering
Rejected hallucinated classes or invalid styles

If the AI generates something outside the system, the update is rejected before it ever touches the UI.

That constraint will save me months later.

Days 3–4: The “Bleeding Edge” Tax (Next.js + Bun Issues)

Using Bun with Next.js 16 is fast — but not always stable.

Hot reload started crashing with cache component errors:

Next.js cannot guarantee that Cache Components will run as expected due to the current runtime's implementation of setTimeout().

Then I hit this:

FATAL: sorry, too many clients already

In a serverless dev environment, every hot reload opened a new Postgres connection.

They weren’t being closed. My database choked.

Fixing “Too Many Clients Already” with Proper Connection Pooling

“Serverless” does NOT mean “Ops-less.”

I implemented strict pooling and ensured a singleton pattern during development:

import { drizzle } from "drizzle-orm/node-postgres";
import { Pool } from "pg";

import * as schema from "./schema";

const connectionString = process.env.DATABASE_URL;

if (!connectionString) {
  throw new Error("DATABASE_URL is missing");
}

const globalForDb = globalThis as unknown as {
  pool: Pool | undefined;
};

const pool =
  globalForDb.pool ??
  new Pool({
    connectionString,
    max: process.env.DB_MAX_CONNECTIONS
      ? parseInt(process.env.DB_MAX_CONNECTIONS, 10)
      : 10,
    idleTimeoutMillis: 30000,
    connectionTimeoutMillis: 2000,
  });

if (process.env.NODE_ENV !== "production") {
  globalForDb.pool = pool;

  pool.on("connect", (client) => {
    console.log(`🔌 Database: New client connected to the pool; client: ${client}`);
  });

  pool.on("error", (err, client) => {
    console.error(`❌ Database: Unexpected error on idle client; client: ${client}`, err);
  });

  pool.on("remove", (client) => {
    console.log(`🗑️ Database: Client removed from pool; client: ${client}`);
  });
}

export const db = drizzle(pool, { schema });

Once I capped connections, everything stabilized.

Lesson: Dev hot reload + serverless Postgres can quietly DOS your own app.

Days 5–6: Implementing Optimistic UI for Instant Feedback

I implemented Optimistic UI for renaming templates.
// Detect dark theme var iframe = document.getElementById('tweet-2021209854837158185-995'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2021209854837158185&theme=dark" }

User types → UI updates immediately.
Server validates in the background.
Failure → rollback.
Success → seamless.

That part worked beautifully.

But the real bottleneck was rendering.

Initial Rendering Pipeline (JavaScript + MJML)

The original rendering pipeline:

JSON stored in DB
JSON → MJML
mjml-browser converts MJML → HTML
HTML rendered inside an iframe

It worked.

But it averaged ~18ms per render.

For a drag-and-drop email builder, that felt sluggish.

Day 7: Replacing JavaScript with Rust + WebAssembly

The bottleneck was mjml-browser (pure JavaScript).

So I replaced it.

I integrated MRML (a Rust port of MJML) compiled to WebAssembly (WASM).

Why?

Rust → predictable performance
MRML → faster MJML parsing
WASM → near-native speed in the browser

Rust Integration Challenges

Rust does not tolerate “almost correct.”

It refused to compile my “sloppy” JSON that JavaScript had been happily ignoring.

It forced me to fix my data structures.

That strictness improved my architecture.

Performance Results: 15x Faster Email Rendering

After integrating MRML via WASM:

JavaScript Engine: ~18ms
Rust (WASM) Engine: ~1.1ms

That’s roughly a 15x performance improvement.

The preview now runs comfortably within a 16ms frame budget — effectively real-time at 60fps.

Unexpected Benefits of Moving to Rust

Cleaner schema enforcement
Deterministic parsing
Smaller rendering bottleneck surface
Future-proof performance foundation

Lessons Learned Building a SaaS in Public (Week 1)

Bleeding-edge stacks save time — until they don’t.
Serverless still requires backend discipline.
Rust’s strictness is a feature, not friction.
Early performance decisions compound.

What’s Next for Ansomail?

Week 1 was about the foundation.

Week 2 is about interaction.

Now that I have a ~1ms rendering engine, I’m building the actual drag-and-drop layer on top of it.

I’m documenting this entire journey publicly.

If you're building with Next.js, Rust, WebAssembly, or experimenting with high-performance SaaS architecture — I’d love to connect.

Ansomail is currently in development. If you're a developer or marketer who struggles with email design systems, I’d love to talk.

SanjayOS: I Built an AI-Powered Operating System for My Portfolio 🚀

Sanjay Kumar Sah — Thu, 29 Jan 2026 10:08:32 +0000

This is a submission for the New Year, New You Portfolio Challenge Presented by Google AI

About Me

Hi there! 👋 I'm Sanjay Sah, a Software Engineer based in India (originally from Nepal) with over two years of experience building high-performance web applications. I currently work at Zuru Tech, where I focus on the MERN stack, Next.js, and crafting smooth user experiences.

I've always felt that standard portfolio websites are... well, a bit static. They tell you about a developer, but they don't show you how they think.

For this challenge, I wanted to break that mold. I wanted to express my love for complex systems, retro aesthetics, and cutting-edge AI. My goal was to build a portfolio that isn't just a document you read, but a system you explore.

Portfolio

Welcome to SanjayOS v1.0 — an AI-native Developer Operating System.

Instead of navigating a menu, you boot into a desktop environment. You can drag windows, run terminal commands, and interact with an intelligent system core.

Go ahead, give it a spin! The entire OS is running serverless on Google Cloud Run.

(If the interactive embed above doesn't load fully, you can launch SanjayOS in a new tab here)

How I Built It

Building an "Operating System" in the browser is no small feat. Here is the architecture that powers SanjayOS:

🛠️ The Tech Stack

Framework: Next.js 16 (App Router) for the core structure.
Runtime: Bun for ultra-fast builds and package management.
Styling: Tailwind CSS + Shadcn/ui (heavily customized for that "Glassmorphism" OS look).
State Management: Zustand to handle the complex window manager logic (z-indexing, minimizing, focusing apps).
Deployment: Dockerized and hosted on Google Cloud Run to handle Server-Side Rendering (SSR) while scaling to zero when idle.

🧠 The Google AI & Antigravity Workflow

The heart of SanjayOS is Google Gemini 2.5 Flash, integrated via the Vercel AI SDK. But the construction of this complex system was accelerated by Google Antigravity.

Built with Antigravity: I used Google's Antigravity (AI-first IDE) to scaffold the complex window management logic and rapidly prototype the Generative UI components. It acted as my "pair programmer," helping me integrate the Gemini API correctly and ensuring my prompt engineering was optimized for tool calling.
System Instructions: I fed the AI a structured JSON context of my entire career (resume, projects, skills). This means no RAG vector database was needed—Gemini's massive context window handles it all in real-time.
Tool Calling: The AI has permission to "control" the OS. If you ask, "Show me Sanjay's projects," Gemini doesn't just write a list; it executes a function to launch the Project Viewer app automatically.

What I'm Most Proud Of

There are three specific achievements I'm thrilled with:

The "Alive" Feeling: The moment you realize the AI isn't just a text box—it's the OS Kernel. Seeing the AI open windows and highlight UI elements based on a conversation feels like the future of web interfaces.
The Window Manager: Building a performant, draggable, resizable window system in React was a complex challenge. Solving the "z-index stacking" (ensuring the clicked window always comes to the front) without causing re-renders was a great engineering puzzle.
The Cloud Run Deployment: Getting a Next.js Docker container to run smoothly on Cloud Run with the correct standalone output and environment variables was a huge win. It proves that personal portfolios can be both high-tech and cost-effective.

I hope you enjoy exploring SanjayOS as much as I enjoyed building it.

Happy Hacking! 💻✨

🎉 From Hackathon Idea to Super Contributor — My Hacktoberfest 2025 Journey

Sanjay Kumar Sah — Tue, 14 Oct 2025 06:55:31 +0000

This is a submission for the 2025 Hacktoberfest Writing Challenge: Open Source Reflections

“Hackathons build projects. Open source builds people.” 💡

Hey everyone 👋 I’m Sanjay Kumar Sah, and this Hacktoberfest was more than just a coding challenge — it was a journey of growth, collaboration, and community.

I started with a small idea from a hackathon project, and ended up becoming a Super Contributor with 6 merged PRs, open-source growth, and even the official Hacktoberfest T-shirt! 🎽

Here’s the story 👇

🌱 The Beginning: Humanizing AI Text

It all began with the Humanizing AI Text Hackathon, organized by Hackathon Raptors.
My goal was simple but exciting:

Make AI-generated text feel more human — natural, emotional, and contextual.

The result?
My project Humanize-AI was born.

And guess what — it ranked 3rd place! 🥉

That recognition gave me the push to take it further — beyond the hackathon and into the open-source world.

🚀 Turning a Hackathon Project into an Open-Source Repo

After the hackathon, I decided to open-source Humanize-AI so others could contribute, improve, and learn from it.

The response was incredible:
⭐ 26 stars
🍴 19 forks
💬 and real collaboration from developers around the world.

It was the first time I saw how powerful open source can be — how a small idea can grow when shared publicly.

Open source isn’t just about publishing your code — it’s about building a community around your ideas.

🤝 From Contributor → Collaborator

This year, I also became an official contributor at NexGenStudioDev.

But instead of just submitting PRs, I started doing code reviews — and that changed everything.

Reviewing others’ code helped me:

Understand new perspectives 👀
Learn clean coding practices 💡
Communicate better as a developer 🧠

Writing code makes you a contributor.
Reviewing code makes you a collaborator.

If you’ve never reviewed a PR before, I highly recommend it.
It’s the fastest way to level up your technical and communication skills.

🏁 The Finish Line: Super Contributor Badge

Completing 6 pull requests this Hacktoberfest earned me the Super Contributor Badge 🏅 — and the classic Hacktoberfest T-shirt 🎽 (the best kind of swag 😄).

But beyond the badge and T-shirt, what I really earned was:

Confidence to contribute anywhere 💪
Deeper respect for maintainers 🛠️
And lifelong connections in the developer community 🌐

📚 What I Learned Along the Way

Here are my top takeaways from this journey:

Start small.
You don’t need a huge project — even a simple idea can inspire others.
Open-source early.
Don’t wait for perfection. Share your work and invite collaboration.
Review more.
Reviewing others’ code teaches you more than writing your own.
Engage with the community.
Hacktoberfest is about people, not just pull requests.
Celebrate progress.
Every PR, every merge, every star — it all counts. 🎉

💬 What’s Next?

I plan to keep improving Humanize-AI with new features and better humanization techniques for AI-generated text.
If you’re interested in NLP, prompt engineering, or AI communication — I’d love to collaborate!

👉 Check it out here: github.com/sanjaysah101/humanize-ai

And if you’re preparing for Hacktoberfest 2026, here’s my advice:

Don’t just aim to complete PRs — aim to connect, learn, and give back.

🫶 Thanks to the Community

A huge shoutout to:

@NexGenStudioDev team
Hackathon Raptors organizers for Humanizing AI Text
Every contributor who starred, forked, or opened an issue

You all made this journey memorable.

🏆 TL;DR – My Hacktoberfest 2025 in Numbers

Category	Highlights
Hackathon	Humanizing AI Text (Ranked 3rd 🥉)
Repo	26+⭐ + 19+🍴
Contributions	6+ PRs merged
Roles	Contributor + Reviewer
Rewards	Super Contributor Badge 🏅 + Official T-shirt 🎽

💌 Final Thoughts

Hacktoberfest isn’t just a celebration of code — it’s a celebration of collaboration.
If you’ve ever hesitated to start, remember:

“The best time to contribute to open source was yesterday. The next best time is today.”

Meet Apicraft – A Zero-Dependency CLI that Replaces Postman, curl, and Mock Servers

Sanjay Kumar Sah — Wed, 01 Oct 2025 12:58:04 +0000

🎨 Introducing Apicraft – A Unified CLI for the Complete API Development Lifecycle

If you’re a developer who lives in the terminal, chances are you juggle multiple tools:

curl for quick requests
Postman or Insomnia for testing and environments
Mock servers for frontend dev
And maybe code snippets for fetch/axios

Wouldn’t it be great if you could do all of that in one CLI tool — with zero dependencies?

That’s exactly why I built Apicraft 🚀

✨ What is Apicraft?

Apicraft is a unified CLI tool for API development. It handles everything from testing to mocking to code generation — all inside your terminal.

🔑 Key features:

🚀 Send beautifully formatted HTTP requests (GET, POST, PUT, DELETE, PATCH)
🔧 Manage environments (dev/prod) and use variable interpolation
💾 Save & replay requests (never retype the same curl again!)
📜 Track request history and replay any request
🎭 Spin up mock servers from JSON files instantly
🔄 Generate fetch/axios/curl code from requests
⚡ Zero dependencies — pure Node.js built-ins

🚀 Quick Start

Install globally:

pnpm install -g @ansospace/apicraft
# or
npm install -g @ansospace/apicraft

First request:

apicraft get https://api.github.com/users/sanjaysah101

Set environments:

apicraft set baseUrl https://api.example.com
apicraft get {{baseUrl}}/users

🎭 Mock Server Example

Need a quick backend while your team builds APIs? Just drop JSON files in a folder and run:

apicraft mock ./mocks 3000

Now you can call:

http://localhost:3000/users

🏆 Why Apicraft?

Unlike Postman, curl, or httpie — Apicraft is:

CLI-native
Zero-dependency
Git-friendly (config in version control)
Includes built-in mocking + code generation

💡 Why I Built This

I created Apicraft for the 100lines.dev Hackathon with a strict 300-line limit. That constraint forced me to focus only on features that matter most — and make them as compact and efficient as possible.

📦 Try it Out

👉 Install from npm: @ansospace/apicraft
👉 GitHub repo: github.com/sanjaysah101/apicraft

Would love to hear your thoughts — what would make this CLI even more useful for your workflow? 🚀

FlagFeed: Gamified Tech Learning with Feature Flags 🚀

Sanjay Kumar Sah — Tue, 17 Dec 2024 16:12:27 +0000

This is a submission for the DevCycle Feature Flag Challenge: Feature Flag Funhouse

Project Overview

FlagFeed is a developer-focused learning platform powered by DevCycle feature flags that combines RSS feed curation with gamification. It helps developers stay updated with tech content through personalized RSS feeds while making learning engaging through gamification.

Key Features ✨

Core Features

📚 Curated tech RSS feeds with real-time updates
🎮 Learn-and-earn points system
🚀 Progressive feature rollouts
✅ Real-time quiz competitions
🔄 Real-time subscriptions
🔐 Row Level Security Implementation

Feature Flags (DevCycle)

🔄 Advanced feed filtering
🏆 Gamification elements
📊 Learning Analytics
🎯 Personalized content

Tech Stack 💻

Frontend & Backend: Next.js 15
Database: PostgreSQL with Prisma ORM
Feature Flags: DevCycle
Deployment: Vercel
Styling: Tailwind CSS with shadcn/ui

How Feature Flags Enhance the Experience 🎯

Progressive Feature Rollouts

Gradually introduce new features like advanced quiz modes
Test UI/UX changes with specific user segments
Enable experimental personalization algorithms

Gamification Controls

Toggle gamification elements like points, badges, and leaderboards
Control difficulty levels and rewards
Enable special events and challenges

Learning Personalization

Toggle AI-powered content recommendations
Control adaptive quiz difficulty
Enable social learning features

Performance & UX
- Control real-time updates frequency
- Toggle advanced filtering options
- Manage resource-intensive features

Demo

Implementation Details 🛠️

Feature Flag Configuration

export const FLAGS = {
  ANALYTICS: {
    ENABLED: "analytics-enabled",
  },
  GAMIFICATION: {
    ENABLED: "gamification-enabled",
    POINT_BOOST: "gamification-point-boost",
    STREAKS: "gamification-reading-streaks",
    ACHIEVEMENTS: "gamification-achievements",
    LEADERBOARD: "gamification-leaderboard",
    DAILY_CHALLENGES: "gamification-daily-challenges",
  },
  RSS: {
    ADVANCED_FILTERING: "rss-advanced-filtering",
    SMART_CATEGORIZATION: "rss-smart-categorization",
  },
  LEARNING: {
    ADAPTIVE_QUIZZES: "learning-adaptive-quizzes",
    LIVE_QUIZZES: "learning-live-quizzes",
  },
  UI: {
    NEW_FEED_LAYOUT: "ui-new-feed-layout",
  },
  FEED: {
    REALTIME_UPDATES: "feed-realtime-updates",
    AI_RECOMMENDATIONS: "feed-ai-recommendations",
  },
};

Feature Flag Usage Examples

// Example 1: Gamification Features
export const GamificationHub = () => {
  const hasAchievements = useVariableValue(FLAGS.GAMIFICATION.ACHIEVEMENTS, false);
  const hasLeaderboard = useVariableValue(FLAGS.GAMIFICATION.LEADERBOARD, false);

  return (
    <div className="space-y-4">
      {hasAchievements && <Achievements />}
      {hasLeaderboard && <Leaderboard />}
    </div>
  );
};

// Example 2: Adaptive Learning
export const Quiz = ({ articleId }: QuizProps) => {
  const isAdaptive = useVariableValue(FLAGS.LEARNING.ADAPTIVE_QUIZZES, false);
  const difficulty = isAdaptive ? calculateUserLevel() : "normal";

  return <QuizContent difficulty={difficulty} />;
};

Live Demo & Repository 🌐

Live Demo: FlagFeed Demo
Repository: GitHub - FlagFeed

Future Enhancements 🔮

AI Integration

Smart content recommendations
Automated quiz generation
Personalized learning paths

Social Features

Reading rooms
Collaborative annotations
Team challenges

Advanced Analytics
- Learning pattern analysis
- Feature usage tracking
- A/B testing insights

Conclusion 🎉

FlagFeed demonstrates how feature flags can enhance the learning experience by enabling progressive rollouts, personalization, and experimental features. Using DevCycle's feature flag system, we've created a platform that can evolve based on user feedback and usage patterns.

How I Won the RetroAI Hackathon 2024: My Solo Journey

Sanjay Kumar Sah — Fri, 18 Oct 2024 17:54:36 +0000

Participating in the RetroAI Hackathon 2024 was a thrilling experience, and I’m excited to share how I secured 3rd place as a solo participant. Competing against some of the best minds in AI and text-based game development, I learned a lot and developed a project I’m proud of. Here’s a breakdown of my journey, my project, and some tips that could help you succeed in your next hackathon.

3rd place in the Retro Quest Hackathon | Sanjay Kumar Sah

I’m happy 😊 to share that I’ve secured 3rd place in the RetroAI Quest Hackathon from Hackathon Raptors! Here is my work: https://lnkd.in/dmafwvVY Github: https://lnkd.in/dk86zYPZ

linkedin.com

About the RetroAI Hackathon

The RetroAI Hackathon is a competitive event focusing on developing AI-driven text adventure games. Participants were challenged to create innovative projects using AI and text-based storytelling. You can learn more about the hackathon here.

Competing as a solo participant, I aimed to create something unique and impactful.

My Project: RetroAI Quest

For this hackathon, I developed RetroAI Quest

sanjaysah101 / RetroAI-Quest

RetroAI quest is a terminal-based, AI-powered text adventure game. Embark on a retro-style, interactive fiction journey where you control the story using natural language commands, experience dynamic story generation, and make decisions that shape your path.

RetroAI quest

RetroAI quest is a terminal-based, AI-powered text adventure game. Embark on a retro-style, interactive fiction journey where you control the story using natural language commands, experience dynamic story generation, and make decisions that shape your path. Powered by artificial intelligence, every game play session offers a unique experience with multiple branching storylines, AI-driven character interactions, and multiple possible endings.

Features

Terminal-Based Interface: Classic text adventure interface with retro-inspired design and terminal commands.
AI-Powered Dynamic Storytelling: The game generates new events and character responses in real-time using AI.
Multiple Branching Paths: Players will encounter multiple decision points leading to different outcomes, adding replayability.
Retro-Inspired Aesthetic: Experience a nostalgic text-based adventure in a terminal interface, complete with retro ASCII art and visual elements.
NLP (Natural Language Processing): Players can interact with the game using free-form commands instead of rigid text options.
Replay ability: Every play through offers a different story…

View on GitHub

The idea behind RetroAI Quest was to combine AI and classic text-based gameplay, creating an engaging story where AI generates dynamic narratives based on player choices.Focus on crafting engaging narratives and innovative AI interactions within a text-only format. Here’s what I focused on:

Core Concept: A text-based adventure game where players interact with AI-generated storylines, making each playthrough unique.
Technology Stack: I used React and Gemini models.
Challenges: Fine-tuning the AI for narrative consistency, balancing AI-generated responses with user input, and creating a seamless user experience.

My Strategy to Win

Understanding the Theme: I dedicated time to thoroughly understanding the hackathon theme and the judges’ expectations, ensuring my project aligned with the criteria.
Planning & Time Management: With a clear timeline, I broke down tasks into manageable milestones, allowing me to focus on coding, testing, and refining the project.
Leveraging AI Tools: Using the Gemini model was key to generating dynamic storylines. I ensured the model could handle diverse inputs and maintain a coherent narrative.
Presentation Matters: I created a polished demo that highlighted the unique aspects of my project, emphasizing how AI contributed to the gameplay experience.

10 Tips for Succeeding in a Hackathon

Start with a Unique Idea: A creative approach helps your project stand out.
Know Your Tools: Mastering your tech stack before the event gives you an edge.
Prioritize Key Features: Focus on core functionality that aligns with the theme.
Time Management is Crucial: Break your project into smaller goals.
Test Frequently: Catch bugs early to save time during the final stretch.
Prepare a Solid Pitch: A well-prepared presentation can make a huge difference.
Stay Focused: Avoid getting sidetracked by less important features.
Be Ready for Challenges: Adapt quickly to technical hurdles.
Interact with Mentors: Use their feedback to refine your project.
Learn from the Experience: Each hackathon is a chance to grow and improve.

What I Learned

Participating solo in the RetroAI Hackathon taught me the importance of balancing creativity with technical skills. I gained valuable insights into AI’s role in interactive storytelling and strengthened my project management skills.

Final Thoughts and Future Goals

This experience was a significant milestone in my journey as a developer. I’m looking forward to applying the lessons learned to future hackathons and projects. If you’re interested in learning more about RetroAI Quest, check out the GitHub repository.

If you found these insights helpful, or if you’ve got questions about hackathons, feel free to leave a comment below! Follow my blog for more stories and tech tips.

PIG GAME 🐗

Sanjay Kumar Sah — Mon, 30 Sep 2024 04:52:45 +0000

This is a submission for the Web Game Challenge, Build a Game: Alien Edition

What I Built

I built an exciting web game called PIG GAME! It's a simple dice game first described in print by John Scarne in 1945. The game is easy to pick up but requires some strategy and luck to win. I implemented it as a fun exercise to practice HTML, CSS, and JavaScript.

Tech Stack 🛠️

HTML5: Structuring the basic elements of the game.
CSS3: Styling the game interface for an engaging user experience.
JavaScript (ES6): Handling the game logic, dice rolls, and user interactions.

The project was a great opportunity to refine my DOM manipulation skills and event handling in JavaScript.

RULES📃TO PLAY GAME

Each turn, a player repeatedly rolls a die until either a 1 is rolled or the player decides to “hold”:

If the player rolls a 1, they score nothing and it becomes the next player's turn.
If the player rolls any other number, it is added to their turn total and the player's turn continues.
If a player chooses to “hold”, their turn total is added to their score, becoming the next player's turn.
Variation we used, if you roll snake eyes (both 1's), your total score from past rounds is reset to 0.

The first player to score 100 or more points wins.

Features ✨

Dynamic Score Updates: The score and dice rolls update live as the player plays.
Winning Screen: A celebratory message displays when a player wins the game.
Snake Eyes Reset Rule: Rolling double ones adds an element of risk, making the game more challenging.

Demo

You can play the Pig game here!

Journey

I built this game using HTML, CSS, and JavaScript as part of a project to enhance my front-end development skills. One of the main challenges was figuring out the logic for handling different game states, such as when the player should roll when they should hold, and how to implement the snake eyes rule.

Additionally, I spent time optimizing the user interface to be responsive and intuitive, ensuring players could enjoy the game on different devices.

This project helped me to improve my understanding of event-driven programming in JavaScript and how to manage state changes in a small game application.