GSoC 2026 Project Ideas

Scrawn is participating in Google Summer of Code 2026! We're excited to mentor students and help them contribute to open-source billing infrastructure.

About Scrawn

Scrawn is a self-hosted billing infrastructure built with event-driven architecture that lets developers integrate usage-based billing with a single function call. We provide:

gRPC Backend: High-performance event-driven server with PostgreSQL, and HTTP/2 (github.com/ScrawnDotDev/Scrawn)
TypeScript SDK: gRPC-powered client library with persistent connections (github.com/ScrawnDotDev/Scrawn.js)
Admin Dashboard: Next.js-based interface for monitoring and management (github.com/ScrawnDotDev/Dashboard)

Organization: ScrawnDotDev

Tech Stack: TypeScript, gRPC/HTTP2, PostgreSQL, Next.js, Drizzle ORM, Connect-RPC

Prerequisites

Before applying, we recommend:

Explore the project: Try deploying Scrawn locally using our Quick Start guide
Make a contribution: Fix a bug or improve documentation to familiarize yourself with the codebase
Join our community: Introduce yourself on Discord and participate in discussions
Read GSoC guidelines: Familiarize yourself with GSoC student responsibilities

How to Apply

Select a project: Choose from the ideas below or propose your own
Write a proposal: Follow the GSoC proposal template
Include:
- Your background and relevant experience
- Detailed implementation plan with timeline
- Deliverables and milestones
- How you'll communicate progress
Submit: Through the GSoC program website during the application period

Project Ideas

1. Scalable AI Token Ingestion System

AI/ML Backend SDK Distributed Systems

Description: Build a fault-tolerant streaming system for real-time AI token usage tracking with automatic recovery and stateless backend design.

The SDK currently uses gRPC with HTTP/2 for persistent connections. This project extends that to handle streaming AI token ingestion with robust failure recovery. When streaming AI tokens, the SDK establishes a dedicated stream with a unique stream ID. As tokens flow in, they're queued to Kafka on the backend. The backend processes events continuously but only acknowledges completion when the entire stream finishes, maintaining statelessness for horizontal scaling.

Key Features:

Stream Recovery: If the SDK-to-backend connection drops mid-stream, the SDK reconnects with the stream ID to resume
Backend Failover: If a backend instance crashes during processing, another instance picks up using the stream ID from Kafka
Response Queueing: Completed stream responses are temporarily stored in a queue with stream IDs. If the SDK reconnects within the timeout window, it retrieves the response; otherwise, entries expire
Developer Experience: The complexity is abstracted inside the SDK—developers just call a function and get back a response, with all the webhook-style async handling hidden

Skills Required:

TypeScript
gRPC/HTTP2 streaming
Kafka message queues
Distributed systems concepts
Error handling and retry logic

Difficulty: Hard

Expected Outcomes:

Streaming API implementation in SDK with automatic reconnection
Kafka-based event queue with stream ID tracking
Stateless backend processing with acknowledgment only on completion
Response queue with TTL for completed streams
Comprehensive error handling and recovery tests
Must preserve the event-driven architecture of the backend

Repositories: Scrawn, Scrawn.js

Mentors: Jaydeep Bejoy, Devyash Saini

Expected Size: 350 hours

2. ML-Powered Dashboard Insights

ML/AI Frontend Dashboard

Description: Integrate lightweight machine learning models into the dashboard to provide predictive analytics for usage patterns and revenue forecasting.

Add intelligent insights directly into the dashboard using client-side or edge-deployed ML models. Analyze historical usage data to predict future trends, identify anomalies, and provide actionable recommendations. This keeps the prediction layer lightweight and doesn't add heavy compute requirements to the core backend.

Skills Required:

Next.js/React
Machine learning basics (TensorFlow.js or similar)
Data visualization (Chart.js, Recharts)
TypeScript
Time series forecasting

Difficulty: Medium

Expected Outcomes:

Integration of lightweight ML model for usage prediction
Revenue forecasting based on historical data
Anomaly detection for unusual usage patterns
Interactive visualizations for predicted vs actual metrics
Dashboard UI components for insights display
Model training pipeline documentation

Repository: Dashboard

Mentors: Devyash Saini, Jaydeep Bejoy

Expected Size: 175 hours

3. Lightweight In-Process Sidecar for SDK-Side Batching

SDK Performance Distributed Systems

Description: Build an in-process sidecar component within the SDK for intelligent event batching and local buffering before transmission to the backend.

Create a lightweight sidecar module that runs within the application process alongside the SDK. It batches events intelligently based on time windows, event counts, or payload size thresholds. This reduces network overhead and backend load while maintaining reliability through local persistence and retry mechanisms.

Skills Required:

TypeScript
Concurrency and async patterns
Local storage/buffering strategies
gRPC batching
Performance optimization

Difficulty: Medium

Expected Outcomes:

In-process batching module with configurable thresholds
Local event buffer with persistence for reliability
Automatic flush on threshold or time-based triggers
Retry logic for failed batch transmissions
Minimal performance overhead on host application
Configuration options for batch size and flush intervals
Comprehensive unit and integration tests

Repository: Scrawn.js

Mentors: Devyash Saini, Jaydeep Bejoy

Expected Size: 175 hours

4. GraphQL API Layer

Backend API Design GraphQL

Description: Add a GraphQL API layer on top of the existing gRPC backend for improved developer experience and flexible data querying.

Build a GraphQL gateway that wraps the gRPC backend services, providing a unified query interface. Support queries, mutations, and real-time subscriptions for events. This gives developers a modern API option while maintaining the performance benefits of gRPC internally.

Skills Required:

GraphQL (Apollo Server, GraphQL Yoga, or similar)
TypeScript/Node.js
gRPC client integration
API design
Real-time subscriptions (WebSockets)

Difficulty: Medium

Expected Outcomes:

GraphQL schema covering all gRPC services
Query and mutation resolvers
Real-time subscriptions for event streams
GraphQL Playground integration for testing
Authentication and authorization pass-through
Comprehensive documentation and examples
Performance benchmarks vs direct gRPC

Repository: Scrawn

Mentors: Jaydeep Bejoy, Devyash Saini

Expected Size: 175 hours

5. Interactive SDK Integration Playground

Developer Experience Frontend Interactive Documentation

Description: Build an interactive playground on the documentation site that demonstrates how easy it is to integrate the Scrawn SDK with real-time code editing and execution simulation.

Create a fully interactive, browser-based environment where developers can experiment with SDK integration patterns without setting up a local environment. The playground simulates the entire SDK workflow—from initialization to event tracking to payment collection—with live code editing, syntax highlighting, and visual feedback. Users can see how the SDK works in different frameworks (Express, Next.js, tRPC) with instant visual results showing API calls, event queues, and backend responses.

Key Features:

Live Code Editor: Monaco Editor with TypeScript support and autocomplete
Framework Templates: Pre-built examples for Express, Next.js, Fastify, tRPC
Visual Flow Simulation: Animated visualization showing SDK → gRPC → Backend → Response flow
Interactive Console: Real-time logs showing event tracking, gRPC calls, and responses
Step-by-Step Tutorials: Guided walkthroughs integrated into the playground

Skills Required:

Next.js
Monaco Editor or CodeMirror integration
State management
Animation libraries (Framer Motion, React Spring)
TypeScript
UI/UX design

Difficulty: Hard

Expected Outcomes:

Interactive code editor with syntax highlighting and IntelliSense
Multiple framework templates (Express, Next.js, Fastify, tRPC)
Visual flow diagram showing SDK execution path
Real-time simulation of API calls and responses
Mobile-responsive design
Integration with existing documentation site
Tutorial mode with step-by-step guidance

Repository: Documentation

Mentors: Devyash Saini, Jaydeep Bejoy

Expected Size: 350 hours

6. Redis-Based API Key Cache with Instant Revocation

Backend Caching Distributed Systems Performance

Description: Replace the in-memory LRU cache with a Redis-based distributed cache system that enables instant API key revocation across all backend instances.

The current system uses a local in-memory Map with LRU eviction (max 1000 entries, 5-minute TTL). While performant for single-instance deployments, it has critical limitations: revoked API keys remain cached until TTL expires (up to 5 minutes), and each backend replica maintains separate cache state. This project replaces the local cache with Redis, enabling instant revocation, shared state across instances, and better scalability.

Key Features:

Distributed Cache: Shared Redis cache across all backend replicas
Instant Revocation: When an API key is revoked in the database, immediately invalidate it in Redis using pub/sub
Backward Compatible: Drop-in replacement for the existing APIKeyCache class interface
Configurable TTL: Maintain existing 5-minute TTL but make it configurable
Graceful Degradation: If Redis is unavailable, fall back to database queries (no caching)
Connection Pooling: Efficient Redis connection management with ioredis