Serverless Functions & API Routes

Temps is a container platform, not a serverless runtime. There are no Lambda-style isolated functions. Instead, your framework's built-in API routes run inside the same container as your application — and Temps adds cron scheduling for background work.

How Temps differs from serverless platforms

On platforms like Vercel or AWS Lambda, each API route or function runs in an isolated ephemeral environment. On Temps, your entire application — frontend and API routes — runs in a single long-lived container.

For most applications, the container model is simpler and more predictable. You avoid cold starts, function size limits, and the complexity of managing dozens of isolated function deployments.

Framework API routes

If your framework supports API routes or server endpoints, they work on Temps without any special configuration. The framework runs as a server inside the container and handles both page requests and API calls.

Next.js API routes

Next.js App Router route handlers and Pages Router API routes both work:

import { NextResponse } from 'next/server';

export async function GET() {
  const users = await db.query('SELECT * FROM users');
  return NextResponse.json(users);
}

export async function POST(request: Request) {
  const body = await request.json();
  const user = await db.insert('users', body);
  return NextResponse.json(user, { status: 201 });
}

Remix loaders and actions

import { json } from '@remix-run/node';
import type { LoaderFunction, ActionFunction } from '@remix-run/node';

export const loader: LoaderFunction = async () => {
  const users = await db.query('SELECT * FROM users');
  return json(users);
};

export const action: ActionFunction = async ({ request }) => {
  const form = await request.formData();
  const user = await db.insert('users', Object.fromEntries(form));
  return json(user, { status: 201 });
};

SvelteKit endpoints

import { json } from '@sveltejs/kit';

export async function GET() {
  const users = await db.query('SELECT * FROM users');
  return json(users);
}

Nuxt server routes

export default defineEventHandler(async (event) => {
  const users = await db.query('SELECT * FROM users');
  return users;
});

All of these work identically on Temps as they do in local development. The framework handles routing, and Temps routes HTTP traffic to the container.

Cron jobs

Temps supports scheduled HTTP calls to your application via the cron section in .temps.yaml. This is the closest equivalent to scheduled serverless functions.

cron:
  - path: /api/cron/cleanup
    schedule: "0 0 * * *"
    name: "Daily Cleanup"

  - path: /api/cron/send-digests
    schedule: "0 9 * * 1"
    name: "Weekly Digest"

  - path: /api/cron/sync-inventory
    schedule: "*/15 * * * *"
    name: "Inventory Sync"

Implementing a cron endpoint

Your cron endpoint is a regular HTTP route. Keep it fast — the cron system sends a request and expects a response.

export async function GET() {
  // Delete expired sessions
  const deleted = await db.query(
    'DELETE FROM sessions WHERE expires_at < NOW()'
  );

  return Response.json({
    deleted: deleted.rowCount,
    timestamp: new Date().toISOString(),
  });
}

Common cron schedules

Standalone API servers

If you are building a pure API (no frontend), deploy it as a regular web application. Temps auto-detects backend frameworks:

import express from 'express';

const app = express();
app.use(express.json());

app.get('/api/users', async (req, res) => {
  const users = await db.query('SELECT * FROM users');
  res.json(users);
});

const port = process.env.PORT || 3000;
app.listen(port, '0.0.0.0');

See the web applications guide for full framework support and auto-detection details.

When to use what

Migrating from serverless platforms

If you are moving from Vercel, Netlify, or AWS Lambda:

From Vercel serverless functions

Vercel functions in api/ or app/api/ are typically Next.js API routes. These work on Temps without changes — Next.js handles the routing regardless of where it runs.

If you used Vercel's @vercel/og or @vercel/blob, replace them with:

• Image generation: Run your own image service or use a library like sharp
• Blob storage: Use the Temps Blob SDK or S3-compatible storage

From AWS Lambda

Lambda handlers need to be wrapped in an HTTP server. Replace the Lambda handler signature with an Express/Fastify route:

export async function handler(event) {
  const users = await getUsers();
  return { statusCode: 200, body: JSON.stringify(users) };
}

import express from 'express';

const app = express();
app.get('/api/users', async (req, res) => {
  const users = await getUsers();
  res.json(users);
});

app.listen(process.env.PORT || 3000, '0.0.0.0');

The business logic stays the same — you only change the HTTP interface.

What to explore next