> ## Documentation Index
> Fetch the complete documentation index at: https://docs.celo.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Scaling Your App

> Learn best practices for scaling your Celo app, covering infrastructure, RPC optimization, caching strategies, and monitoring

Scaling an app requires careful planning across infrastructure, blockchain interactions, and cost optimization. This guide shares practical strategies from real-world experience building and scaling applications on Celo.

## Overview

As your app grows, costs can scale exponentially if not managed properly. This guide covers:

* Infrastructure and hosting strategies
* RPC and blockchain interaction optimization
* Caching and data management
* AI/LLM cost optimization
* Testing and monitoring best practices

## Infrastructure & Hosting

### Server Architecture

Start simple, but plan for growth:

* **Early Stage**: Begin with a single server to minimize costs
* **Monitor Usage**: Track CPU, memory, and network usage closely
* **Plan Migration**: Be ready to migrate to scalable solutions like:
  * **Kubernetes (K8s)**: For container orchestration and auto-scaling
  * **Docker Swarm**: Lighter alternative for container management
  * **Managed Services**: Consider AWS ECS, Google Cloud Run, or similar

<Info>
  Monitor your server metrics from day one. Set up alerts for CPU, memory, and
  disk usage to catch scaling issues before they impact users.
</Info>

### Image Hosting & CDN

Avoid expensive default CDNs:

* **Don't Use**: Vercel's default CDN (can be expensive at scale)
* **Use Instead**: Cost-effective CDN solutions like:
  * Cloudflare (free tier available)
  * AWS CloudFront
  * BunnyCDN
  * ImageKit or Cloudinary for image optimization

<Warning>
  CDN costs can add up quickly with high traffic. Choose a CDN with predictable
  pricing and monitor bandwidth usage.
</Warning>

### Backend Architecture

Separate your backend from your frontend for better scaling:

* **Avoid**: Next.js API routes for production workloads
* **Use Instead**: Separate backend service (Node.js, Python, Go, etc.)
* **Benefits**:
  * Scale backend independently without increasing Vercel pricing
  * Better control over resources and deployment
  * Easier to implement queues, caching, and background jobs

<Info>
  Use Next.js API routes only for lightweight, user-specific operations. Move
  heavy processing, RPC calls, and background jobs to a separate backend
  service.
</Info>

### Message Queues

Implement queues wherever they make sense:

* **Use Cases**:

  * Processing blockchain transactions
  * Sending notifications
  * Background data processing
  * Image processing
  * Email/SMS sending

* **Queue Solutions**:
  * **Redis + BullMQ**: Lightweight and fast
  * **RabbitMQ**: Robust message broker
  * **AWS SQS**: Managed queue service
  * **Google Cloud Tasks**: Managed task queue

<Info>
  Queues prevent request timeouts, improve user experience, and allow you to
  process jobs at your own pace without overwhelming your server.
</Info>

## RPC & Blockchain Interactions

### RPC Strategy

RPC calls are a precious resource—treat them carefully:

* **Choose Scalable RPC Providers**:

  * Use providers with high rate limits and good uptime
  * Consider multiple RPC endpoints for redundancy
  * Monitor RPC response times and error rates

* **Early Stage Strategy**:

  * Use free RPC endpoints in the frontend
  * Each user gets their own rate limits
  * Reduces backend RPC load

* **Scale Considerations**:
  * RPC usage scales exponentially with user growth
  * Audit all RPC calls regularly
  * Remove unnecessary RPC calls
  * Batch requests when possible

<Warning>
  RPC costs can become your largest expense. Audit your RPC calls regularly and
  optimize aggressively. A single unnecessary RPC call per user can cost
  thousands at scale.
</Warning>

### Caching Strategy

Cache API responses wherever it makes sense:

* **Don't Always Fetch Latest Data**:

  * Cache blockchain data that doesn't change frequently
  * Use appropriate TTLs (Time To Live) based on data freshness requirements
  * Balance between data freshness and RPC costs

* **Cache Layers**:

  * **In-Memory Cache**: Redis or Memcached for frequently accessed data
  * **CDN Cache**: For static or semi-static content
  * **Application Cache**: Cache responses in your application layer

* **What to Cache**:
  * Token balances (with short TTL)
  * Token metadata
  * Historical transaction data
  * Price data (with appropriate TTL)
  * Contract ABIs

<Info>
  Most blockchain data doesn't need to be real-time. Cache aggressively and only
  fetch fresh data when absolutely necessary.
</Info>

### Indexer Selection

If you need an indexer, choose cost-effective options:

* The Graph (decentralized indexing)
* [Envio](/build/tools/indexers/envio) (self-host HyperIndex or deploy to Envio Cloud)
* Alchemy (if you already use their RPC)
* thirdweb Insight
* A custom indexer, if none of the hosted options fit

See [Indexers](/build/tools/indexers/overview) for the providers documented on Celo.

<Info>
  Indexers can significantly reduce RPC calls by providing pre-indexed
  blockchain data. Choose one that fits your budget and requirements.
</Info>

## AI & LLM Optimization

### Model Selection

Optimize LLM costs by choosing the right model for each task:

* **Small Tasks**: Use cheaper models (e.g., GPT-3.5-turbo, Claude Haiku)
* **Complex Tasks**: Reserve expensive models (e.g., GPT-4, Claude Opus) only when necessary
* **Consider Alternatives**:
  * Open-source models (Llama, Mistral)
  * Specialized models for specific tasks

<Info>
  Most tasks don't require the most powerful models. Use cheaper models for
  simple tasks and save expensive models for complex reasoning.
</Info>

### AI SDK

Use AI SDKs for better developer experience:

* **Benefits**:

  * Better error handling
  * Built-in retry logic
  * Streaming support
  * Cost tracking
  * Easier model switching

* **Recommended SDKs**:
  * [Vercel AI SDK](https://sdk.vercel.ai/) for JavaScript/TypeScript
  * [LangChain](https://www.langchain.com/) for Python
  * [LlamaIndex](https://www.llamaindex.ai/) for data indexing

## Testing & Monitoring

### Testing Strategy

Comprehensive testing prevents costly production issues:

* **Unit Tests**: Test individual functions and components
* **Integration Tests**: Test how different parts work together
* **E2E Tests**: Test complete user flows
* **Load Tests**: Test your application under expected load
* **Reburst Tests**: Test how your system handles sudden traffic spikes

<Warning>
  Don't skip testing. Production bugs are expensive to fix and can damage user
  trust. Invest in a solid testing strategy from the start.
</Warning>

### Error Monitoring

Use Sentry to audit error rates:

* **Benefits**:

  * Track error rates over time
  * Get alerts for error spikes
  * Debug production issues quickly
  * Monitor performance issues

* **Setup**:
  * Install Sentry SDK in your application
  * Configure error tracking
  * Set up alerts for critical errors
  * Monitor error trends

<Info>
  Sentry helps you catch and fix errors before they impact too many users. Set
  up error monitoring from day one.
</Info>

### Analytics & Logging

Use Grafana for analytics and logs:

* **Metrics to Track**:

  * Request rates and response times
  * Error rates
  * RPC call counts and costs
  * Server resource usage
  * User activity metrics

* **Logging**:

  * Centralized logging with Grafana Loki or similar
  * Structured logging (JSON format)
  * Log retention policies
  * Search and query capabilities

* **Dashboards**:
  * Create dashboards for key metrics
  * Set up alerts for anomalies
  * Monitor trends over time

<Info>
  Good observability helps you catch issues early and make data-driven decisions
  about scaling. Invest in monitoring from the start.
</Info>

## Best Practices Summary

### Cost Optimization Checklist

* [ ] Use cost-effective CDNs instead of default options
* [ ] Separate backend from frontend for independent scaling
* [ ] Implement message queues for background processing
* [ ] Cache API responses aggressively
* [ ] Audit and optimize RPC calls regularly
* [ ] Use free RPC endpoints in frontend during early stages
* [ ] Choose affordable indexers when needed
* [ ] Use cheaper LLM models for simple tasks
* [ ] Monitor all costs and set up alerts

### Scaling Readiness Checklist

* [ ] Monitor server metrics (CPU, memory, disk)
* [ ] Have a plan to migrate to scalable infrastructure (K8s, Docker Swarm)
* [ ] Implement comprehensive testing (unit, integration, E2E, load)
* [ ] Set up error monitoring (Sentry)
* [ ] Configure analytics and logging (Grafana)
* [ ] Document your architecture and scaling plan
* [ ] Set up alerts for critical metrics

## Additional Resources

* [Celo Documentation](/build) - Explore Celo development resources
* [Launch Checklist](/build/launch-checklist) - Pre-launch preparation guide
* [Indexers](/build/tools/indexers/overview) - Indexing providers documented on Celo
* [Vercel AI SDK](https://sdk.vercel.ai/) - AI SDK for JavaScript/TypeScript
* [Sentry Documentation](https://docs.sentry.io/) - Error monitoring and performance tracking
* [Grafana Documentation](https://grafana.com/docs/) - Analytics and observability platform


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.