Popular searches

Serverless Computing

Functions Run Code, Not Servers

Serverless functions that scale automatically

Deploy serverless functions with automatic scaling, built-in monitoring, and pay-per-execution pricing. Perfect for APIs, webhooks, and event-driven applications.

Deploy Function View Examples
0ms
Cold Start
$0.000012
Per Request
15min
Max Runtime
index.js
package.json
export default async (req, res) => {
  const { name } = req.query;
  
  // Your serverless logic here
  const response = await fetch(`/api/users/${name}`);
  const user = await response.json();
  
  return res.json({
    message: `Hello ${user.name}!`,
    timestamp: new Date().toISOString()
  });
};
HTTP Request
↓
Function Execution
↓
JSON Response

Serverless, simplified

Everything you need for production-ready serverless functions

Instant Scaling

Automatically scale from zero to thousands of concurrent executions in milliseconds.

  • Zero cold starts
  • Automatic concurrency
  • Global edge execution

Multiple Runtimes

Support for Node.js, Python, Go, and custom runtime environments.

  • Node.js 18, 16, 14
  • Python 3.9, 3.8
  • Go 1.19

Edge Computing

Execute functions at the edge for ultra-low latency responses worldwide.

  • 150+ edge locations
  • Sub-10ms latency
  • Automatic geo-routing

Built-in Monitoring

Real-time metrics, logs, and distributed tracing for all function executions.

  • Real-time metrics
  • Structured logging
  • Error tracking

Enterprise Security

Built-in security with authentication, rate limiting, and environment isolation.

  • Function-level auth
  • Rate limiting
  • Secret management

Pay Per Use

Only pay for actual function execution time. No charges for idle time.

  • Per-millisecond billing
  • No idle costs
  • Free tier included

Ready-to-use examples

Get started with these common serverless patterns

REST API

Node.js
export default async (req, res) => {
  const { method } = req;
  
  switch (method) {
    case 'GET':
      return res.json({ users: await getUsers() });
    case 'POST':
      const user = await createUser(req.body);
      return res.status(201).json(user);
    default:
      return res.status(405).end();
  }
};
HTTP Methods Database JSON Response

Image Processing

Python
from PIL import Image
import json

def handler(event, context):
    # Process uploaded image
    image = Image.open(event['image'])
    
    # Resize and optimize
    image.thumbnail((800, 600))
    
    # Return processed image URL
    return {
        'statusCode': 200,
        'body': json.dumps({
            'processed_url': upload_to_storage(image)
        })
    }
Image Processing File Upload Storage

Webhook Handler

Go
package main

import (
    "encoding/json"
    "net/http"
)

func Handler(w http.ResponseWriter, r *http.Request) {
    var payload WebhookPayload
    json.NewDecoder(r.Body).Decode(&payload)
    
    // Process webhook
    result := processWebhook(payload)
    
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(result)
}
Webhooks Event Processing High Performance

Scheduled Tasks

Node.js
export default async (req, res) => {
  // Run every hour via cron: 0 * * * *
  
  try {
    // Cleanup expired sessions
    await cleanupExpiredSessions();
    
    // Send daily report
    await sendDailyReport();
    
    return res.json({ 
      success: true, 
      timestamp: new Date() 
    });
  } catch (error) {
    return res.status(500).json({ error: error.message });
  }
};
Cron Jobs Automation Background Tasks

Simple, transparent pricing

Pay only for what you use, down to the millisecond

Calculate your costs

Estimated Monthly Cost

Requests: $1.20
Compute Time: $0.84
Total: $2.04
Free tier: 1M requests + 400,000 GB-seconds/month

Pricing Details

Resource
Price
Free Tier
Requests
$0.000012 per request
1M requests/month
Compute Time
$0.000000167 per GB-second
400,000 GB-seconds/month
Data Transfer
$0.09 per GB
1 GB/month

Perfect for any use case

From simple APIs to complex event-driven architectures

API Backends

Build scalable REST APIs and GraphQL endpoints that scale automatically with demand.

  • RESTful services
  • GraphQL resolvers
  • Authentication middleware
  • Data validation

Webhooks & Integrations

Handle webhooks from third-party services and integrate with external APIs seamlessly.

  • Payment processing
  • GitHub webhooks
  • Slack integrations
  • CRM sync

Data Processing

Process files, transform data, and handle batch operations without managing infrastructure.

  • Image resizing
  • PDF generation
  • CSV processing
  • Data transformation

Automation & Cron Jobs

Schedule recurring tasks and automate workflows with reliable execution.

  • Database cleanup
  • Report generation
  • Email campaigns
  • Backup operations

Deploy your first function in minutes

Multiple ways to get started with HostEngine Functions

Deploy with CLI

# Install the CLI
npm install -g @hostengine/cli

# Login to your account
hostengine login

# Create a new function
hostengine functions:create hello-world

# Deploy to production
hostengine functions:deploy

Deploy from GitHub

1
Connect your GitHub repository
2
Functions are auto-detected from /api folder
3
Automatic deployments on git push

Start building serverless today

Deploy your first function for free. No credit card required.

Deploy Free Function Read Documentation
1M free requests/month
Zero cold starts
Global edge execution