How to run serverless-style apps in Replit

Start a new Replit App by clicking '+ Create App' on your Replit dashboard. Choose Node.js as the template. This creates a clean workspace with Node.js pre-configured. Unlike a traditional serverless platform, Replit gives you a full Linux environment, so you can use any npm packages, run background tasks, and access the file system. Each microservice should be its own separate Repl to maintain isolation and independent scaling.

Install Express and create a lightweight API server. The key difference from a traditional web app is that this server has no frontend, no HTML templates, and no static file serving. It only responds to API requests with JSON. Every route should return structured JSON responses. Make sure to bind to 0.0.0.0 on the port Replit expects, and include a health check endpoint at the root path that responds within 5 seconds since Replit's deployment health check requires this.

1npm install express cors

Structure your API with clear route separation and consistent error handling. Each route acts like an independent serverless function that handles one concern. Use try-catch blocks around all async operations and return appropriate HTTP status codes. Include request validation and meaningful error messages in JSON format. This pattern makes each endpoint independently testable and debuggable.

1const express = require('express');
2const cors = require('cors');
3const app = express();
4
5app.use(cors());
6app.use(express.json());
7
8// Health check - required for Autoscale deployment
9app.get('/', (req, res) => {
10  res.json({ status: 'healthy', service: 'user-api', version: '1.0.0' });
11});
12
13// Serverless-style function: process user data
14app.post('/api/users/validate', async (req, res) => {
15  try {
16    const { email, name } = req.body;
17    if (!email || !name) {
18      return res.status(400).json({ error: 'Email and name are required' });
19    }
20    const isValid = email.includes('@') && name.length >= 2;
21    res.json({ valid: isValid, email, name, timestamp: new Date().toISOString() });
22  } catch (error) {
23    res.status(500).json({ error: 'Internal server error' });
24  }
25});
26
27// Serverless-style function: generate report
28app.get('/api/reports/:type', async (req, res) => {
29  try {
30    const { type } = req.params;
31    const validTypes = ['daily', 'weekly', 'monthly'];
32    if (!validTypes.includes(type)) {
33      return res.status(400).json({ error: `Invalid type. Use: ${validTypes.join(', ')}` });
34    }
35    res.json({ report: type, generated: new Date().toISOString(), data: [] });
36  } catch (error) {
37    res.status(500).json({ error: 'Internal server error' });
38  }
39});
40
41const PORT = 3000;
42app.listen(PORT, '0.0.0.0', () => {
43  console.log(`API server running on port ${PORT}`);
44});

Update your .replit configuration to optimize for an API-only service. Set the run and deployment commands, configure the port mapping so Replit routes external traffic to your server, and set the deployment target to cloudrun for Autoscale support. The deployment run command should not include npm install since the build step handles dependency installation.

1entrypoint = "index.js"
2run = "node index.js"
3
4[nix]
5channel = "stable-24_05"
6
7[deployment]
8run = ["sh", "-c", "node index.js"]
9build = ["sh", "-c", "npm install"]
10deploymentTarget = "cloudrun"
11
12[[ports]]
13localPort = 3000
14externalPort = 80

Store any sensitive configuration in Replit Secrets rather than environment variables in code. Open Tools in the left sidebar and click Secrets. Add each key-value pair your service needs, such as database connection strings, third-party API keys, or JWT signing secrets. Access these in your code using process.env.SECRET_NAME. Remember that you must add secrets separately in the Deployments pane when you deploy, as workspace secrets do not automatically carry over to production.

1// Access secrets in your Express routes
2const dbUrl = process.env.DATABASE_URL;
3const apiKey = process.env.THIRD_PARTY_API_KEY;
4
5if (!dbUrl) {
6  console.error('DATABASE_URL secret is not configured');
7  process.exit(1);
8}

Click the Deployments tab in the top right of your workspace. Select Autoscale as the deployment type. Configure the CPU and RAM to the minimum your service needs (start with the smallest tier). Set the maximum number of machines based on your expected traffic. Review the estimated cost. Click Deploy. Autoscale will build your project, start the health check, and make your API available at a public URL. The service scales to zero instances after 15 minutes of inactivity and cold-starts on the next incoming request.

For a microservice architecture, create separate Replit Apps for each service. Each gets its own Autoscale deployment with an independent URL. Services communicate via HTTP requests to each other's deployment URLs. Store the URLs of other services as Secrets so they are not hardcoded. This pattern gives you independent scaling, independent deployments, and fault isolation between services, which is the core benefit of microservice architecture. RapidDev's engineering team recommends keeping each service focused on a single domain (users, payments, notifications) for maintainability.

1// In your user-service, call the notification-service
2const notificationServiceUrl = process.env.NOTIFICATION_SERVICE_URL;
3
4app.post('/api/users/register', async (req, res) => {
5  try {
6    // Register user logic...
7    const user = { id: '123', email: req.body.email };
8    
9    // Notify the notification service
10    await fetch(`${notificationServiceUrl}/api/notify`, {
11      method: 'POST',
12      headers: { 'Content-Type': 'application/json' },
13      body: JSON.stringify({ type: 'welcome', userId: user.id })
14    });
15    
16    res.json({ user, notified: true });
17  } catch (error) {
18    res.status(500).json({ error: 'Registration failed' });
19  }
20});