> ## Documentation Index
> Fetch the complete documentation index at: https://docs.ollie.shop/llms.txt
> Use this file to discover all available pages before exploring further.
# Functions
> Build custom integrations that were impossible or too expensive before. Add your business logic between any services to solve integration challenges that SaaS platforms don't support.
{/*
Integration Challenge Keywords: custom business logic, API enhancement, SaaS platform limitations, enterprise integration costs, impossible integrations, $50K+ solutions
Common User Questions:
- How do I add custom logic between two APIs?
- Can I enhance an existing API without changing it?
- How do I solve integration challenges that my SaaS platform doesn't support?
- What's the difference between request, response, and task functions?
- How do I transform API responses with custom business rules?
Related Concepts: Hub proxy, API transformation, serverless functions, business rule automation, integration middleware
*/}
Stop accepting "that's not supported" from SaaS platforms. Functions let you add custom business logic between any services, solving integration challenges that were previously impossible or cost \$50K+ to build. Turn platform limitations into competitive advantages.
Add custom logic between any services. Transform data, apply business rules, coordinate multiple systems that don't talk to each other.
Build custom integrations for the cost of coffee, not enterprise consulting projects. Deploy instantly, scale automatically.
## Real-World Examples
See how businesses use functions to solve everyday problems:
**Problem:** Handle customer orders, process payments, manage inventory
```typescript title="Order Processing Function" icon="shopping-cart" theme={"system"}
export const handler = async (event) => {
const { items, customerId, paymentMethod } = JSON.parse(event.body);
// Validate inventory
const available = await checkInventory(items);
if (!available) {
return { statusCode: 409, body: 'Items out of stock' };
}
// Process payment
const payment = await processPayment(paymentMethod);
// Create order
const order = await createOrder({ items, customerId, payment });
// Send confirmation
await sendOrderConfirmation(order);
return {
statusCode: 201,
body: JSON.stringify({ orderId: order.id, total: order.total })
};
};
```
**What it handles:**
* ✅ Inventory validation
* ✅ Secure payment processing
* ✅ Order creation and tracking
* ✅ Customer notifications
**Problem:** User authentication, feature access, usage tracking
```typescript title="User Authentication Function" icon="users" theme={"system"}
export const handler = async (event) => {
const { email, password } = JSON.parse(event.body);
// Authenticate user
const user = await validateCredentials(email, password);
if (!user) {
return { statusCode: 401, body: 'Invalid credentials' };
}
// Generate secure token
const token = await generateJWT(user);
// Track login analytics
await trackUserLogin(user.id);
return {
statusCode: 200,
body: JSON.stringify({
token,
user: { id: user.id, email: user.email, plan: user.plan }
})
};
};
```
**What it enables:**
* ✅ Secure user authentication
* ✅ JWT token generation
* ✅ User analytics tracking
* ✅ Role-based access control
**Problem:** Process uploads, generate thumbnails, moderate content
```typescript title="Content Processing Function" icon="photo" theme={"system"}
export const handler = async (event) => {
const { fileUrl, userId, contentType } = JSON.parse(event.body);
// Download and validate file
const file = await downloadFile(fileUrl);
const isValid = await validateContent(file, contentType);
if (!isValid) {
return { statusCode: 400, body: 'Invalid content' };
}
// Generate thumbnails and process
const thumbnails = await generateThumbnails(file);
const processedFile = await optimizeForDelivery(file);
// Save to CDN
const urls = await uploadToCDN([processedFile, ...thumbnails]);
return {
statusCode: 200,
body: JSON.stringify({ originalUrl: urls[0], thumbnails: urls.slice(1) })
};
};
```
**What it provides:**
* ✅ Automated content validation
* ✅ Thumbnail generation
* ✅ CDN optimization
* ✅ Media processing pipeline
**Problem:** Real-time analytics, user behavior tracking, reporting
```typescript title="Analytics Processing Function" icon="chart-bar" theme={"system"}
export const handler = async (event) => {
const analyticsEvents = JSON.parse(event.body);
// Process each event
for (const eventData of analyticsEvents) {
// Enrich with user context
const enrichedEvent = await enrichEventData(eventData);
// Real-time analytics
await updateRealTimeMetrics(enrichedEvent);
// Store for batch processing
await queueForBatchAnalysis(enrichedEvent);
}
// Generate insights
const insights = await generateRealTimeInsights();
return {
statusCode: 200,
body: JSON.stringify({ processed: analyticsEvents.length, insights })
};
};
```
**What it tracks:**
* ✅ Real-time user behavior
* ✅ Conversion funnels
* ✅ Performance metrics
* ✅ Business intelligence
## Three Types of Functions
Choose the right function type for your use case:
**Process incoming HTTP requests**
Request functions run when users visit URLs or submit forms. They handle login, payment processing, API calls, and any user interaction that needs an immediate response.
**Modify responses before sending to users**
Response functions automatically enhance responses from request functions. They add analytics, security headers, personalized content, or dynamic pricing without changing your core logic.
**Run scheduled or background jobs**
Task functions execute on schedules or delays without user interaction. They send emails, generate reports, clean up data, and automate workflows in the background.
## Why Developers Choose Functions
Write code, hit deploy. Your function is live and handling requests in seconds, not hours.
Handle one request or one million. Functions scale automatically based on demand.
Skip the DevOps complexity. No servers, containers, or Kubernetes to manage.
Only pay when your functions run. No idle server costs or infrastructure overhead.
Authentication, encryption, and security headers included. Focus on features, not security.
See function performance, errors, and usage in real-time. Debug issues instantly.
## Common Use Cases
**What you can build:**
* Order processing and fulfillment
* Payment gateway integration
* Inventory management
* Customer support chatbots
* Recommendation engines
* Fraud detection systems
**Example businesses using this:**
* Online stores processing thousands of orders daily
* Subscription services managing recurring billing
* Marketplaces connecting buyers and sellers
**What you can build:**
* User authentication and registration
* Push notification systems
* File upload and processing
* Real-time chat and messaging
* Social media features
* Content management systems
**Example businesses using this:**
* Social apps with millions of users
* Productivity tools and collaboration platforms
* Content creators and media companies
**What you can build:**
* Real-time analytics dashboards
* Data pipeline processing
* Machine learning model serving
* ETL (Extract, Transform, Load) workflows
* Business intelligence reporting
* A/B testing platforms
**Example businesses using this:**
* SaaS companies tracking user behavior
* Financial institutions processing transactions
* Healthcare systems analyzing patient data
**What you can build:**
* Email marketing campaigns
* Customer onboarding flows
* Data backup and archival
* System health monitoring
* Content moderation
* Invoice and billing automation
**Example businesses using this:**
* Marketing agencies managing campaigns
* Enterprise companies automating processes
* Startups scaling operations efficiently
## Best Practices for Success
**Do one thing well**
Each function should have a single responsibility. This makes them easier to test, debug, and maintain.
**Always plan for failure**
Use try-catch blocks, return meaningful error messages, and implement proper HTTP status codes.
**Keep secrets secure**
Never hardcode API keys or passwords. Use environment variables for configuration and secrets.
**Know what's happening**
Add logging for debugging and monitoring for performance. Track errors and usage patterns.
**Keep it fast**
Minimize cold starts, cache when possible, and use efficient algorithms and data structures.
**Prevent issues early**
Write unit tests, integration tests, and use local development tools to catch issues before deployment.
## Ready to Start Building?
Deploy your first function in under 2 minutes. Step-by-step tutorial with working examples.
Set up your development environment and test functions locally before deployment.
**New to serverless?** Functions are just code that runs in the cloud. You write the logic, we handle the infrastructure. Start with our [Quick Start guide](/ollie-hub/getting-started/quickstart) to deploy your first function in minutes.