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.
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
};
}Data persists across sessions
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
| Task | Time |
|---|---|
| Set up server infrastructure (AWS/GCP/Azure) | 2-3 days |
| Configure auto-scaling and load balancing | 1-2 days |
| Set up database (PostgreSQL/MySQL) | 1-2 days |
| Configure database migrations and backups | 1 day |
| Set up Redis for caching and sessions | 1 day |
| Configure monitoring and alerting (Datadog/New Relic) | 1-2 days |
| Set up CI/CD pipeline | 1-2 days |
| Configure security and authentication | 1-2 days |
| Set up logging and error tracking | 1 day |
| Testing and debugging infrastructure | 2-3 days |
| Documentation and team onboarding | 1-2 days |
With SLC Workers
| Task | Time |
|---|---|
| ✓Write your worker function | 5 min |
| ✓Deploy with `slc deploy` | 30 sec |
| ✓Start using your backend | Instant |
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.
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 };
}Deploy
One command. Your backend is live in seconds.
// 2. Deploy
slc deployUse 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.