Pikku - Write Once, Run Everywhere | Pikku

src/functions/cards.function.ts

export const getCard = pikkuFunc<
  { cardId: string },
  { id: string; title: string; status: string }
>({
  func: async ({ database, channel }, { cardId }) => {
    const card = await database.query('cards', {
      where: { id: cardId }
    })

    // Works with WebSocket channels and SSE too!
    if (channel) {
      await channel.send({ type: 'card-fetched', card })
    }

    return card
  },
  permissions: { owner: requireOwner },
  docs: {
    summary: 'Fetch a card by ID',
    tags: ['cards']
  }
})

wireHTTP({
  method: 'get',
  route: '/cards/:cardId',
  func: getCard
})

export const onboardingWorkflow = pikkuWorkflowFunc(
  async ({ workflow }, { email, userId }) => {
    // Step 1: Create user profile (RPC step)
    const user = await workflow.do(
      'Create user profile',
      'createUserProfile',
      { email, userId }
    )

    // Step 2: Add to CRM (inline step)
    const crmUser = await workflow.do(
      'Create user in CRM',
      async () => crmApi.createUser(user)
    )

    // Step 3: Wait 5 minutes
    await workflow.sleep(
      'Wait before welcome email',
      '5min'
    )

    // Step 4: Send welcome email (RPC step)
    await workflow.do(
      'Send welcome email',
      'sendEmail',
      { to: email, template: 'welcome' }
    )

    return { success: true }
  }
)

1. Deterministic Replay

Completed steps are cached and never re-executed. Workflows resume from where they left off after failures or delays.

2. Persistent State

Store state in any database—PostgreSQL and Redis support out of the box. Survives server restarts and you don't pay for the time it isn't running.

3. Time-Based Steps

Sleep steps for delays, reminders, trial expirations, and scheduled follow-ups.

4. RPC & Inline Steps

Mix RPC calls (via queue workers) with inline code. Full type safety across all steps.

Alex Harley

Co-founder @ Superbridge

Christoph Sitter

CTO @ spot

Type-Safe Clients

Auto-generated from your function definitions

HTTP fetch, WebSocket, and RPC clients with full IntelliSense

Auth & Permissions

Built-in filters, no manual checks

Cookie, bearer, API key auth with fine-grained permissions

Services

Singleton and per-request injection

Database, logger, config—all type-safe and testable

Middleware

Before/after hooks across all protocols

Logging, metrics, tracing—work everywhere

Schema Validation

Auto-validate against TypeScript input schemas

Runtime validation catches errors before they hit your functions

Zero Lock-In

Standard TypeScript, no magic

Tiny runtime, bring your own database/logger/tools

~2.8MB

All functions, all protocols

~180KB

Only admin routes + dependencies

~50KB

Single endpoint + minimal runtime

Fastify

Next.js

AWS Lambda

Cloudflare