Shopping carts that never reset. No backend setup.
Build a shopping cart that remembers items 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 { action, productId, quantity } = ctx.request.body;
// Get or initialize cart
const cart = state.cart || [];
if (action === 'add') {
// Add item to cart
const existingItem = cart.find(item => item.productId === productId);
if (existingItem) {
existingItem.quantity += quantity || 1;
} else {
cart.push({ productId, quantity: quantity || 1 });
}
} else if (action === 'remove') {
// Remove item from cart
state.cart = cart.filter(item => item.productId !== productId);
}
// Save state - persists automatically!
await ctx.state.set({ cart });
return {
cart,
totalItems: cart.reduce((sum, item) => sum + item.quantity, 0)
};
}Cart persists across sessions
No Redis or database needed
The Problem
Why frontend developers don't build
You have an idea. You want to build it. But the backend setup is so overwhelming that you never start. Sound familiar?
Weeks of setup
Setting up servers, databases, Redis, and monitoring takes forever
Expensive infrastructure
Pay $200-500/month even when you're just experimenting
Constant maintenance
Keep everything updated, scaled, and monitored
Backend complexity
You're a frontend dev—why do you need to learn all this?
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 waitlist to get early access. Build real-time features in minutes, not weeks. No servers, no databases, just your code with memory.