Skip to main content

Pikku

One Function, Every Protocol

Write TypeScript functions once, trigger them via HTTP, WebSocket, cron jobs, queues, and more. Pikku is the swiss knife for building scalable applications with full type safety.

Same function can handle RPC, HTTP, SSE, WebSocket, CronJobs, Queues, and MCP
Auto-generated mini TypeScript SDKs with complete type safety
Deploy anywhere - Express, Lambda, Cloudflare, Next.js, Azure and more

All the tools needed for scaleable backend platforms

Build your backend with all the different tools you need, without having to learn a new framework for each decision

Built for Developers

Pikku provides everything you need to build robust, type-safe applications with minimal setup.

🎯

Fully Typed

Complete type safety from server to client with automatic type generation

🔐

Auth & Permissions

Built-in authentication, sessions, and granular permission system

Middleware

Hook into your functions with middleware for logging, custom validation, and more

⚙️

Service Injection

Simple dependency injection without decorators or magic

HTTP APIs

Build REST APIs and handle HTTP requests with full type safety and automatic OpenAPI generation.

Runs on:

Features:

  • Automatic OpenAPI documentation
  • Auth & Permissions
  • Middleware
  • Progressively enhancement to stream

WebSocket & Real-time

Build real-time applications with typed WebSocket connections and pub/sub messaging.

Runs on:

Features:

  • Run locally or in a serverless environments
  • Route to functions based on message action
  • Built-in pub/sub system

Server-Sent Events

Stream real-time data to clients with automatic reconnection and progressive enhancement.

Runs on:

Features:

  • Simple streaming API
  • Provide realtime updates
  • Typed streaming data
  • Typed SSE Client

Background Queues

Process background jobs with reliable message delivery and retry logic.

Runs on:

?
?

Features:

  • Switch out different queue providers, unlocking scaling opportunities
  • Supports different queue providers, without locking you in with code.

Scheduled Tasks

Run cron jobs and scheduled tasks that work across all deployment environments.

Runs on:

Features:

  • Cron expression support
  • Timezone handling
  • Error retry logic
  • Serverless friendly

RPC & Services

Build type-safe RPC services with automatic client generation and service discovery.

Runs on:

Features:

  • Automatic client generation
  • Service discovery
  • Type-safe service calls
  • Request/response validation

MCP Server

Expose your Pikku functions as Model Control Protocol tools, enabling AI models to interact with your backend services directly.

Runs on:

Features:

  • AI model integration
  • Tool and resource exposure
  • Type-safe AI interactions
  • Multiple transport support

Monoliths, Services, Functions, you can have it all

Build your application architecture your way with Pikku's flexible approach to deployment and bundling.

📦

Minimal Bundle Generation

Tree-shake all the services your code doesn't need for optimal bundle sizes

🎯

Service Filtering

Pick and choose which services you want to deploy by filtering via tag, files or transport type

Functionless Optimised

Select a single function to deploy via Lambda/Cloudflare and let Pikku pluck out the core dependencies

Deploy Anywhere, Scale Everywhere

From serverless functions to traditional servers, from SQS Lambda queues to serverless WebSockets - your Pikku code runs everywhere without modification.

☁️

Serverless First

AWS Lambda, Cloudflare Workers, Vercel Functions - deploy with zero configuration

SQS Lambda Queues
Serverless WebSockets
Scheduled Functions
🖥️

Traditional Servers

Express, Fastify, Next.js - integrate with existing applications seamlessly

Middleware Integration
Docker Deployment
Kubernetes Ready
🔧

Custom Runtimes

Build your own runtime adapter for any environment or platform

Custom HTTP Handlers
WebSocket Adapters
Scheduler Handlers
🚀It's all an adapter away

Pikku glues together the pieces you need, so you can build an adaptor to run in any environment.