SLC.RUN
Backend logic that remembers

Backend features that remember. No backend setup.

Build stateful features that persist data even after users close the browser. No sessions, Redis, or databases needed. Just write your code and deploy.

Get Early Access
No credit cardDeploy in minutes
5 min
Setup Time
$0.01
Per Request
0
Infrastructure
export default async function handler(ctx) {
  const state = await ctx.state.get();
  const { userId, message } = ctx.request.body;
  
  // Get or initialize messages
  const messages = state.messages || [];
  
  // Add new message with timestamp
  messages.push({
    userId,
    message,
    timestamp: Date.now()
  });
  
  // Save state - persists automatically!
  await ctx.state.set({ messages });
  
  return { 
    messages,
    messageCount: messages.length
  };
}
Persistent State

Data persists across sessions

Zero Infrastructure

No Redis or database needed

The Problem

Building stateful features shouldn't require a database

You want to add a counter, a chat room, or a shopping cart. But serverless functions are stateless, so you need Redis or a database—just for simple stateful operations.

💾

Need state? You need a database

Serverless functions are stateless. Want a counter or session? Time to set up Redis or a database.

🔌

Database setup for simple things

Chat rooms, shopping carts, rate limiting—each needs its own database setup and connection management.

📚

Learning curve for state

You're comfortable with React, but adding backend state means learning databases, Redis, and connection pooling.

Overkill for simple state

A full database or Redis instance just to track a counter or store a session feels like too much.

The Solution

SLC: Backend logic that remembers, zero setup required

Stop worrying about infrastructure. Focus on building features. SLC handles all the backend complexity so you can ship faster.

✍️

Write your code

Just write a simple function. No infrastructure knowledge needed.

🚀

Deploy instantly

One command. Your backend is live in seconds.

💾

State persists automatically

Your code remembers everything. No databases to manage.

What You Can Build

Real features, built in minutes

These aren't demos. These are real features you can build today. Each one would take weeks with traditional backend setup. With SLC, it's minutes.

💬

Real-time Chat App

Problem

Building chat requires WebSockets, message storage, and real-time sync. That's weeks of work.

Solution

Each chat room is an actor that remembers all messages. Add a message, it persists. No database needed.

// Chat room backend
const messages = state.messages || [];
messages.push({ userId, text, time });
await state.set({ messages });
return { messages };
🛒

Shopping Cart

Problem

Shopping carts reset on page refresh. You need sessions, Redis, and database setup.

Solution

Each user's cart is an actor. Add items, they persist. Close the browser? Still there when you return.

// Shopping cart backend
const cart = state.cart || [];
cart.push({ productId, quantity });
await state.set({ cart });
return { cart };
🎮

Multiplayer Game State

Problem

Game state needs real-time sync, conflict resolution, and persistence. Complex backend required.

Solution

Each game room is an actor. Player moves update state instantly. State persists between sessions.

// Game state backend
const players = state.players || {};
players[userId] = { x, y, score };
await state.set({ players });
return { players };
📊

Live Dashboard

Problem

Real-time dashboards need WebSockets, data aggregation, and caching layers.

Solution

Each dashboard is an actor. Update metrics, they persist. View anytime, always current.

// Dashboard backend
const metrics = state.metrics || {};
metrics[metricName] = value;
await state.set({ metrics });
return { metrics };

Rate Limiter

Problem

API rate limiting needs Redis, distributed locks, and careful configuration.

Solution

Each API key is an actor. Track requests, enforce limits. No Redis needed.

// Rate limiter backend
const requests = state.requests || [];
requests.push(Date.now());
const recent = requests.filter(t => t > Date.now() - 60000);
await state.set({ requests: recent });
return { remaining: 100 - recent.length };
🔐

User Sessions

Problem

Sessions need secure storage, expiration logic, and database management.

Solution

Each user session is an actor. Store data, it persists. Set expiration, it cleans up.

// Session backend
await state.set({ 
  userId, 
  data, 
  expiresAt: Date.now() + 3600000 
});
return { session: await state.get() };

The Difference

Stop spending weeks on setup. Start building in minutes.

See how SLC compares to traditional backend setups. Every task, every minute counted.

Traditional Setup

1 week
Total Time
$0/month
Monthly Cost
TaskTime
Set up server infrastructure (AWS/GCP/Azure)2-3 days
Configure auto-scaling and load balancing1-2 days
Set up database (PostgreSQL/MySQL)1-2 days
Configure database migrations and backups1 day
Set up Redis for caching and sessions1 day
Configure monitoring and alerting (Datadog/New Relic)1-2 days
Set up CI/CD pipeline1-2 days
Configure security and authentication1-2 days
Set up logging and error tracking1 day
Testing and debugging infrastructure2-3 days
Documentation and team onboarding1-2 days

With SLC Workers

0 min
Total Time
$0.00/request
Pay Per Use
TaskTime
Write your worker function5 min
Deploy with `slc deploy`30 sec
Start using your backendInstant

0.0% less time

Time saved vs traditional setup

How It Works

Three steps. That's it.

No servers. No databases. No complexity. Just write, deploy, and use.

01

Write your code

Just write a simple function. No infrastructure setup needed.

// 1. Write your worker
export default async function handler(ctx) {
  const state = await ctx.state.get();
  state.count = (state.count || 0) + 1;
  await ctx.state.set(state);
  return { count: state.count };
}
02

Deploy

One command. Your backend is live in seconds.

// 2. Deploy
slc deploy
03

Use it

Call your function. State persists automatically between calls.

// 3. Use it
fetch('https://api.slc.run/v1/invoke/my-app/user-123', {
  method: 'POST',
  body: JSON.stringify({})
});

Early Access

Ready to build without the backend hassle?

Join the early access list via our Zoho form. Build real-time features in minutes, not weeks. No servers, no databases, just your code with memory.