How Replit works with serverless architectures

True serverless platforms like AWS Lambda run individual functions that spin up per request, execute, and shut down. You pay only for execution time measured in milliseconds, and scaling is effectively infinite. Replit Autoscale works differently: it runs your full application process (an Express server, Flask app, or any HTTP server) on Google Cloud Run containers. When no traffic arrives for 15 minutes, all instances scale to zero. When a request arrives, a new instance boots your entire application. Scaling is horizontal, adding more instances up to a configurable maximum, not running individual functions. This means Autoscale is better for traditional web apps and APIs than for event-driven function architectures.

After 15 minutes of no traffic, Autoscale scales to zero instances. The next incoming request triggers a cold start, which typically takes 10 to 30 seconds depending on your app size, dependency count, and initialization logic. During this time the user waits. To minimize cold start impact, reduce your app's startup time by lazy-loading heavy modules, deferring database migrations to a separate process, and keeping your dependency tree lean. Your homepage must respond within 5 seconds or the health check fails and the deployment is marked unhealthy.

1// Minimize cold start time with lazy loading
2import express from 'express';
3
4const app = express();
5
6// Health check endpoint - responds immediately
7app.get('/', (req, res) => {
8  res.status(200).json({ status: 'ok', timestamp: Date.now() });
9});
10
11// Heavy modules loaded only when needed
12app.post('/api/analyze', async (req, res) => {
13  // Import heavy dependency only when this route is hit
14  const { analyzeData } = await import('./services/analyzer.js');
15  const result = await analyzeData(req.body);
16  res.json(result);
17});
18
19// Bind to 0.0.0.0 - required for Replit deployments
20const PORT = process.env.PORT || 3000;
21app.listen(PORT, '0.0.0.0', () => {
22  console.log(`Server ready on port ${PORT}`);
23});

Open the .replit file and add a deployment section that tells Replit how to build and run your app in production. The deployment run command should start your production server, not the development server. The build command runs before deployment and is where you install dependencies and compile assets. Set the deploymentTarget to cloudrun for Autoscale. Make sure your server binds to 0.0.0.0 and uses the PORT environment variable, as Replit assigns the port dynamically in production.

1entrypoint = "src/server.js"
2run = "node src/server.js"
3
4[nix]
5channel = "stable-24_05"
6packages = ["nodejs-20_x"]
7
8[[ports]]
9localPort = 3000
10externalPort = 80
11
12[deployment]
13run = ["node", "src/server.js"]
14build = ["npm", "install", "--production"]
15deploymentTarget = "cloudrun"

Replit sets the REPLIT_DEPLOYMENT environment variable to 1 in deployed apps. Use this to switch behavior between development and production. For example, enable detailed error logging in development but return generic error messages in production. Use REPLIT_DEV_DOMAIN for development-only features and REPLIT_DOMAINS for production URLs. Remember that REPLIT_DEV_DOMAIN does not exist in deployments, so always check before using it.

1const isProduction = process.env.REPLIT_DEPLOYMENT === '1';
2
3const config = {
4  port: parseInt(process.env.PORT || '3000'),
5  isProduction,
6  logLevel: isProduction ? 'error' : 'debug',
7  domain: isProduction
8    ? process.env.REPLIT_DOMAINS
9    : process.env.REPLIT_DEV_DOMAIN,
10  corsOrigins: isProduction
11    ? [`https://${process.env.REPLIT_DOMAINS}`]
12    : ['*'],
13};
14
15export default config;

Open the Deployments pane from the Tools dock. Select Autoscale as the deployment type. Configure the CPU and RAM sliders based on your app's needs. Set the maximum machine count to control how many instances can run simultaneously. A higher count handles more concurrent traffic but increases potential cost. Add all required secrets in the deployment configuration because workspace secrets do not transfer automatically. Review the estimated cost based on your settings before deploying.

Replit Autoscale charges a $1/month base fee plus $1 per million compute units and $0.40 per million requests. AWS Lambda charges per request ($0.20 per million) and per compute duration ($0.0000166667 per GB-second). For low-traffic apps, Autoscale's $1 base fee exceeds Lambda's pure pay-per-use model. For moderate traffic, the costs are comparable. For high-traffic apps, Lambda is typically cheaper for simple functions while Autoscale is simpler to manage for full web applications. Replit's advantage is zero DevOps overhead: no IAM roles, API Gateway setup, or CloudFormation templates. For teams that need both the simplicity of Replit and advanced serverless for specific workflows, RapidDev can help architect hybrid solutions.