Leap

https://docs.leap.new/
Admin
Leap is an AI developer agent that builds production-ready applications and deploys them to your own...
Tokens:21,965
Snippets:88
Trust Score:6.9
Update:1 year ago
Show doc for...
Tokens:
Raw
### Build a Todo App (Basic)

Source: https://docs.leap.new/best-practices/prompting

This example shows a basic prompt to build a todo app. It's a starting point for demonstrating how to instruct Leap.

```text
Build a todo app.

```

--------------------------------

### Generate Movie Recommendation API Service (TypeScript)

Source: https://docs.leap.new/getting-started/quickstart

This snippet demonstrates the structure of a Leap service for a movie recommendation API. It defines an API endpoint for searching movies and integrates with Encore's SQL database for data storage and retrieval. The code utilizes Encore's framework for defining type-safe APIs and managing database connections.

```TypeScript
// movies/encore.service.ts
import { api } from "encore.dev/api";
import { SQLDatabase } from "encore.dev/storage/sqldb";
const db = new SQLDatabase("movies", {
  migrations: "./migrations",
});
export const search = api(
  { method: "GET", path: "/movies/search" },
  async ({ query }: { query: string }) => {
    // Your movie search logic here
    return await searchMovies(query);
  }
);

```

--------------------------------

### Stripe Integration Prompt Example

Source: https://docs.leap.new/integrations/stripe

An example prompt to generate a Stripe integration for subscription billing, including handling failed payments and cancellations via webhooks.

```Prompt
Add Stripe payments for subscription billing with three tiers,
one-time product purchases, and automatic invoice generation with
webhook handling for failed payments and cancellations

```

--------------------------------

### OpenAI Integration Prompt Example

Source: https://docs.leap.new/integrations/openai

This example prompt demonstrates how to describe AI needs for content generation and chat support using OpenAI models within the Leap platform. It outlines requirements for creating blog posts, product descriptions, and a chat feature with conversation history.

```text
Add AI content generation using OpenAI that creates blog posts from user topics,
generates product descriptions from specifications,
and provides AI chat support with conversation history

```

--------------------------------

### Example Prompt for Tigris Integration

Source: https://docs.leap.new/integrations/tigris

This example prompt demonstrates how to describe storage needs for user profile images, document uploads, and video storage with specific features like automatic resizing, virus scanning, CDN delivery, and signed URLs for private content.

```Prompt
Add file storage using Tigris for user profile images with automatic resizing,
document uploads with virus scanning, and video storage with CDN delivery
and signed URLs for private content
```

--------------------------------

### Anthropic Integration Example Prompt

Source: https://docs.leap.new/integrations/anthropic

This example prompt demonstrates how to describe your Claude AI integration needs for customer support. It specifies analyzing user messages, providing intelligent responses from documentation, and automatically escalating complex issues.

```plaintext
Add Claude AI for customer support that analyzes user messages,
provides intelligent responses based on documentation,
and escalates complex issues to human agents automatically

```

--------------------------------

### Resend Integration Prompt Example

Source: https://docs.leap.new/integrations/resend

This example prompt demonstrates how to request email sending functionality using Resend for various scenarios like user sign-ups, password resets, and order confirmations with attachments. Leap uses these descriptions to generate the integration code.

```Prompt
Add email sending using Resend for welcome emails when users sign up,
password reset links with secure tokens,
and order confirmations with PDF receipts attached

```

--------------------------------

### Build an Expense Tracking App (Real Example)

Source: https://docs.leap.new/best-practices/prompting

This prompt is provided as a real-world example that consistently produces great results for building an expense tracking app.

```text
Build an expense tracking app where users can:
- Log expenses with amounts, dates, and categories
- See monthly spending summaries
- Set budget limits for different categories
- Get notifications when approaching budget limits

```

--------------------------------

### Build an API for Product Inventory (Backend)

Source: https://docs.leap.new/best-practices/prompting

This example shows a prompt for a backend-focused application, specifically an API for a product inventory system.

```text
Build an API for a product inventory system with:
- Product management (create, update, search)
- Inventory tracking across multiple warehouses
- Order processing that updates inventory levels
- Low stock alerts

```

--------------------------------

### Prisma ORM Integration Example Prompt

Source: https://docs.leap.new/integrations/prisma

This example prompt demonstrates how to configure Encore services to import and use PrismaClient with Leap. It shows the necessary import statements and client instantiation, including how Leap handles connection strings and client generation.

```TypeScript
Each Encore service must import the db and create its own instance of a PrismaClient, e.g:
import db from "../dbs/main";
import { PrismaClient } from "../dbs/main/gen/client";
export const prisma = new PrismaClient({ datasources: { db: {url: db.connectionString}}});
Migration files will be automatically generated by Prisma on build.
The client will be automatically generated on build and placed in the ./main/gen/client module
```

--------------------------------

### Prompt for PostHog Integration

Source: https://docs.leap.new/integrations/posthog

This example prompt demonstrates how to describe analytics needs for integrating PostHog with Leap. It covers user signups, feature usage, conversion funnels with A/B testing, and session recording for debugging.

```prompt
Add PostHog analytics to track user signups,
feature usage, and conversion funnels with A/B testing for new features
and session recording for debugging user issues

```

--------------------------------

### Build Fitness Class Scheduling Platform

Source: https://docs.leap.new/best-practices/prompting

This snippet demonstrates how to start a prompt for building a fitness class scheduling and management platform. It outlines the core purpose and key user features.

```text
Build a platform for scheduling and managing fitness classes...
Users should be able to:
- Book classes based on availability
- Manage their bookings
- Receive reminders before class
The application should use PostgreSQL for data storage and include user authentication.
```

--------------------------------

### Build a Book Review Site (Data Description)

Source: https://docs.leap.new/best-practices/prompting

This example illustrates how to describe data entities and their relationships when prompting Leap to build a book review site.

```text
Build a book review site where users can:
- Rate books (1-5 stars)
- Write reviews
- See other users' reviews
- Browse books by genre

```

--------------------------------

### Build a Task Management App (Specific)

Source: https://docs.leap.new/best-practices/prompting

This example demonstrates a more specific prompt for building a task management app, highlighting the importance of detailed requirements.

```text
Build a task management app where users can create projects, add tasks with due dates,
and assign them to team members.

```

--------------------------------

### Implement Clerk Authentication

Source: https://docs.leap.new/tutorials/authentication

This snippet demonstrates the prompt to initiate Clerk authentication setup within Leap. It specifies storing the secret key using Leap's secrets manager and the publishable key as an environment variable in `config.ts`.

```text
Implement authentication using Clerk. Store the secret key using secrets and the publishable key as an environment variable in config.ts.
```

--------------------------------

### Integrate Resend and Stripe (Third-Party)

Source: https://docs.leap.new/best-practices/prompting

This example demonstrates how to prompt Leap to integrate with third-party services like Resend for email and Stripe for payments.

```text
Build a newsletter platform that uses Resend for email delivery and Stripe for subscription payments.

```

--------------------------------

### Example of a detailed bug report

Source: https://docs.leap.new/best-practices/debugging

This snippet illustrates an effective bug report that provides clear context, steps to reproduce, expected vs. actual behavior, and specific error messages, enabling Leap to provide a more accurate fix.

```text
When I click the "Save" button on the form, nothing happens.  
Expected: The form should save and show a success message.  
Actual: No response, and the following error appears in the console: "TypeError: handleSubmit is not defined".
```

--------------------------------

### Example of a vague bug report

Source: https://docs.leap.new/best-practices/debugging

This snippet demonstrates a poor bug report that lacks specific details, making it difficult for Leap to diagnose and fix the issue.

```text
It's broken, fix it
```

--------------------------------

### Accessing Encore Cloud Dashboard for Observability

Source: https://docs.leap.new/understanding-your-leap-app/monitoring-and-observability

This guide explains how to access the Encore Cloud dashboard to view your application's observability features. It involves deploying the app to Encore Cloud and then visiting the app dashboard to explore the running system with production-grade monitoring.

```bash
1. Click “Deploy” to deploy your app to Encore Cloud
2. Visit your app dashboard at https://app.encore.cloud
3. Explore your running system with production-grade monitoring
```

--------------------------------

### Leap Codebase Structure and Git Integration

Source: https://docs.leap.new/understanding-your-leap-app/leap-interface

Explore your complete codebase structure within Leap, featuring a file explorer for services and components, real-time code editing with syntax highlighting, and Git change tracking with diff viewing. It integrates directly with your GitHub repository and follows Encore's service-based architecture.

```text
File explorer showing your services and components
Real-time code editing with syntax highlighting
Git change tracking and diff viewing
Direct integration with your GitHub repository
The file structure follows Encore’s service-based architecture where each folder represents a microservice.
```

--------------------------------

### Connect GCP Account for Deployment

Source: https://docs.leap.new/deployment/overview

This section provides step-by-step guidance on connecting your Google Cloud Platform (GCP) account to Leap for deployment. It highlights the advantages of using Encore Cloud to automate deployments to your GCP infrastructure, such as simplified CI/CD, data sovereignty, compliance, cost management, and enhanced security.

```bash
## Connect GCP Account
Step-by-step GCP setup
```

--------------------------------

### Sample Application Prompt Template

Source: https://docs.leap.new/best-practices/prompting

A general template for structuring prompts to Leap AI when requesting application development. It covers application type, problem solved, key functionality, and technical/design requirements.

```text
Build a [type of application] that helps users [solve this problem].
Key functionality:
- [Feature 1]
- [Feature 2]
- [Feature 3]
The application should have:
- [Any specific technical requirements]
- [Any specific design requirements]
```

--------------------------------

### Grant Organization Policy Administrator Role in GCP

Source: https://docs.leap.new/deployment/gcp

Instructions for granting the 'Organization Policy Administrator' role to a user within a GCP organization. This role is required for initial setup of domain-restricted sharing.

```bash
gcloud organizations add-iam-policy-binding ORGANIZATION_ID \
    --member=user:USER_EMAIL \
    --role=roles/orgpolicy.policyAdmin
```

--------------------------------

### Define Encore Service with API and Database (TypeScript)

Source: https://docs.leap.new/understanding-your-leap-app/encore-services

This snippet demonstrates how to define a microservice using Encore.ts, including setting up a SQL database and creating an HTTP API endpoint for user creation. It highlights automatic infrastructure provisioning and type safety.

```TypeScript
// users/encore.service.ts
import { api } from "encore.dev/api";
import { SQLDatabase } from "encore.dev/storage/sqldb";
// This creates a database for this service
const db = new SQLDatabase("users", {
  migrations: "./migrations",
});
// This creates an HTTP API endpoint
export const createUser = api(
  { method: "POST", path: "/users" },
  async (data: CreateUserRequest): Promise<User> => {
    // Your business logic here
    return await db.queryRow`
      INSERT INTO users (email, name)
      VALUES (${data.email}, ${data.name})
      RETURNING *
    `;
  }
);

```

--------------------------------

### Connect AWS Account for Deployment

Source: https://docs.leap.new/deployment/overview

This section outlines the process for connecting your AWS account to Leap for deployment. It details the benefits of using Encore Cloud for automating deployments to your AWS infrastructure, including one-click deploys, data sovereignty, compliance, cost control, and security.

```bash
## Connect AWS Account
Complete guide for AWS deployment
```

--------------------------------

### Encore.ts API with Rust Validation

Source: https://docs.leap.new/getting-started/introduction

This snippet demonstrates how Encore.ts enables high-performance APIs with multi-threaded Rust validation. It highlights the framework's capability to handle complex backend logic and ensure data integrity through robust validation mechanisms.

```TypeScript
import { api, service } from '@encore/encore';

interface User {
  id: string;
  name: string;
}

@service()
class UserService {
  @api({
    method: 'POST',
    path: '/users',
    validate: {
      body: User
    }
  })
  async createUser(user: User) {
    // Rust validation ensures user object conforms to the User interface
    // ... create user in database ...
    return { success: true };
  }
}
```

--------------------------------

### Encore.ts Framework Overview

Source: https://docs.leap.new/getting-started/introduction

Encore.ts is an open-source framework used by Leap to build distributed systems. It provides high-performance APIs with Rust validation, infrastructure-as-code for AWS/GCP provisioning, type-safe service communication, and built-in observability features like distributed tracing and metrics.

```TypeScript
import { createEncoreApp } from '@encore/encore';

const app = createEncoreApp();

app.registerService('myService', async () => {
  // Service logic here
});

app.listen();
```

--------------------------------

### Leap vs Bolt Key Differences Table

Source: https://docs.leap.new/comparisons/leap-vs-bolt

This table outlines the key differences between Leap and Bolt across various aspects including their development approach, deployment targets, backend capabilities, infrastructure management, and support for distributed systems.

```Markdown
| Leap | Bolt  
---|---|---
**Approach** | Production-grade distributed systems | Browser-based development  
**Deploys to your own cloud (AWS/GCP)** | ✅ Yes | ❌ No  
**Real backend logic & microservices** | ✅ Yes | ❌ Limited  
**Infrastructure-as-code by default** | ✅ Yes | ❌ No  
**Built-in distributed tracing** | ✅ Yes | ❌ No  
**Multi-environment support** | ✅ Yes | ❌ Limited  
**Type-safe distributed systems** | ✅ Yes | ❌ No  
**Avoids vendor lock-in** | ✅ Yes | ❌ No  
```

--------------------------------

### Encore.ts Framework Features

Source: https://docs.leap.new/index

Leap applications are built on Encore.ts, an open-source framework designed for building distributed systems. Encore.ts provides high-performance APIs with Rust validation, infrastructure-as-code for automatic provisioning on AWS/GCP, type-safe service communication, and built-in observability features like distributed tracing and metrics.

```TypeScript
import { api } from "encore.dev/api";
import { db } from "encore.dev/db";

// Define a service
export const userService = api.service({
  // Define API endpoints
  getUser: api.method({ ... })
});

// Define a database schema
export const User = db.model({
  id: db.id(),
  name: db.string(),
  email: db.string().unique()
});
```

```Rust
// Example of Rust validation within Encore.ts (conceptual)
#[derive(Debug, serde::Deserialize)]
struct UserInput {
    name: String,
    email: String,
}

impl UserInput {
    fn validate(&self) -> Result<(), &'static str> {
        if self.name.is_empty() {
            return Err("Name cannot be empty");
        }
        if !self.email.contains('@') {
            return Err("Invalid email format");
        }
        Ok(())
    }
}
```

--------------------------------

### Tips to reduce token usage in Leap

Source: https://docs.leap.new/best-practices/tokens

Provides practical advice for users to reduce token consumption in Leap. Key recommendations include merging changes frequently, using the 'Scope context' feature to limit the codebase analyzed by the AI, and avoiding repetitive 'Fix with Leap' actions.

```English
Here are some simple ways you can reduce token usage and improve performance:
### 

Merge early and often
When you first send a prompt in Leap, it creates a **Change** for the ongoing chat with the AI. You can think of this as a branch. Whenever you have accomplished an atomic implementation in your application, we recommend clicking **Merge change** and continuing with a new one. You can think of this as merging a pull request. Merging early and often ensures the context passed to the AI is focused only on what is relevant for the changes you are currently working on.
### 

Use Scope context
If you have a large codebase, manually defining what part of the codebase is send to the AI can be used to significantly optimize token usage. Click **Scope context** in the prompt text area to select which files and folders are relevant to the change you are working on. **Example:** If you are asking the AI to only make UI changes on a specific page, use the Scope context feature to select the relevant page.
### 

Avoid repeated “Fix with Leap” attempts
Repeatedly clicking **Fix with Leap** can quickly consume unnecessary tokens. After an attempt, review the changes and refine your next request if needed. Not every issue can be fixed automatically, without providing more context to the AI, so it’s often worth debugging the error or making manual edits if fixes fail.
### 

Add error handling and logging
If you’re stuck in an error loop, prompt Leap to add detailed logging and stronger error handling. Leap is good at inserting useful logs at key steps, and these logs help the AI understand what’s going wrong and allow it to respond with more precise fixes in future attempts.
### 

Use the Undo functionality
If something goes wrong, you can **Undo** the latest revision and return to the previous state without consuming any tokens. This is more efficient than asking the AI revert the change.
Undoing a revision is permanent, there’s no redo, so make sure you’re ready before using it.
```

--------------------------------

### Algolia Integration for Instant Search

Source: https://docs.leap.new/integrations/other

Add Algolia to your project for instant search capabilities. It offers typo tolerance, faceting, and personalized results, enhancing user experience for content discovery.

```text
Add Algolia for instant search with typo tolerance,
faceting, and personalized results
```

--------------------------------

### Slack Bot for System Status

Source: https://docs.leap.new/integrations/other

Create a Slack bot that posts updates to channels and responds to commands for system status.

```python
Create Slack bot that posts updates to channels and responds
to commands for system status
```

--------------------------------

### Notion Integration for Content Management

Source: https://docs.leap.new/integrations/other

Connect Notion for centralized content management, documentation synchronization, and collaborative workspace features. Keep your team aligned and informed.

```text
Connect Notion for content management, documentation sync,
and collaborative workspace features
```

--------------------------------

### Linear Integration for Project Management

Source: https://docs.leap.new/integrations/other

Integrate Linear for efficient project management, issue tracking, and automated workflow updates. Streamline your development process with this tool.

```text
Integrate Linear for project management, issue tracking,
and automated workflow updates
```

--------------------------------

### Pipedrive Integration for Sales Pipeline

Source: https://docs.leap.new/integrations/other

Implement Pipedrive for effective sales pipeline management, deal tracking, and activity automation. Visualize and manage your sales process efficiently.

```text
Implement Pipedrive for sales pipeline management,
deal tracking, and activity automation
```

--------------------------------

### Replicate AI Model Integration

Source: https://docs.leap.new/integrations/other

Integrate Replicate for image generation using hosted AI models, with queue management for processing.

```python
Add image generation using Replicate's hosted AI models
with queue management for processing
```

--------------------------------

### AI Platform Integration Combination

Source: https://docs.leap.new/integrations/other

An integration stack for AI-powered applications, combining OpenAI for AI models, Pinecone for vector search, Supabase for backend, and Vercel for deployment.

```text
OpenAI + Pinecone + Supabase + Vercel for AI-powered applications
```

--------------------------------

### Pinecone Integration for Semantic Search

Source: https://docs.leap.new/integrations/other

Integrate Pinecone for semantic search, recommendation systems, and AI-powered content discovery. It enables understanding of context and meaning in search queries.

```text
Add Pinecone for semantic search, recommendation systems,
and AI-powered content discovery
```

--------------------------------

### Amplitude User Behavior Analysis

Source: https://docs.leap.new/integrations/other

Implement Amplitude for user behavior tracking, cohort analysis, and product insights with custom properties.

```python
Implement Amplitude for user behavior tracking, cohort analysis,
and product insights with custom properties
```

--------------------------------

### Meilisearch Integration for Fast Search

Source: https://docs.leap.new/integrations/other

Integrate Meilisearch for fast, typo-tolerant search with instant results and faceted filtering. It provides a seamless search experience for users.

```text
Integrate Meilisearch for fast, typo-tolerant search
with instant results and faceted filtering
```

--------------------------------

### Hugging Face ML Workflows

Source: https://docs.leap.new/integrations/other

Integrate Hugging Face models for text classification, sentiment analysis, and custom machine learning workflows.

```python
Integrate Hugging Face models for text classification,
sentiment analysis, and custom ML workflows
```

--------------------------------

### Configure CNAME Record for Custom Domain

Source: https://docs.leap.new/deployment/custom-domains

This snippet shows the required CNAME record details to connect a custom domain to your Leap application. It specifies the type, the DNS record (subdomain), and the value provided by Encore.

```text
Type: CNAME
DNS Record: api.your-domain.com (your subdomain)
Value: custom-domain.encr.app
```

--------------------------------

### Mapbox Integration for Custom Maps

Source: https://docs.leap.new/integrations/other

Implement Mapbox for custom map styling, navigation, and location-based features using vector tiles. Create unique and interactive map experiences.

```text
Implement Mapbox for custom map styling, navigation,
and location-based features with vector tiles
```

--------------------------------

### Make Integration for Workflow Automation

Source: https://docs.leap.new/integrations/other

Implement Make for complex workflow automation, featuring visual scenario building and data transformation capabilities. Create sophisticated automated processes.

```text
Implement Make for complex workflow automation
with visual scenario building and data transformation
```

--------------------------------

### New Relic Observability

Source: https://docs.leap.new/integrations/other

Add New Relic for full-stack observability, distributed tracing, and infrastructure monitoring.

```python
Add New Relic for full-stack observability, distributed tracing,
and infrastructure monitoring
```

--------------------------------

### Leap's token usage explanation

Source: https://docs.leap.new/best-practices/tokens

This section explains how Leap utilizes AI models like Anthropic's Claude 4 Sonnet and Google's Gemini, and how these models process tokens. It defines tokens and explains that Leap is billed by AI providers based on token usage, influencing pricing plans.

```English
Leap uses Anthropic’s Claude 4 Sonnet and Google’s Gemini models to power its AI. These models process _tokens_ , which is defined by Anthropic as:
> The smallest individual units of a language model. A token can represent a word, part of a word, a character, or even a byte (especially in the case of Unicode).
Each token comes with a cost, and Leap is billed by the AI providers for each token it uses. This is why our paid plans are priced based on how many tokens you get in each plan.
```

--------------------------------

### Zapier Integration for Workflow Automation

Source: https://docs.leap.new/integrations/other

Add Zapier webhooks for powerful workflow automation, enabling integration with over 5000 applications. Connect your tools and automate tasks.

```text
Add Zapier webhooks for workflow automation
and integration with 5000+ applications
```

--------------------------------

### GitHub Repository Management

Source: https://docs.leap.new/integrations/other

Add GitHub integration for repository management, issue tracking, and automated deployment workflows.

```python
Add GitHub integration for repository management, issue tracking,
and automated deployment workflows
```

--------------------------------

### Cohere Text Generation and Search

Source: https://docs.leap.new/integrations/other

Implement Cohere for text generation, semantic search, and classification with multilingual support.

```python
Implement Cohere for text generation, semantic search,
and classification with multilingual support
```

--------------------------------

### Google Workspace Integration for Productivity

Source: https://docs.leap.new/integrations/other

Add Google Workspace integration for seamless document management, calendar synchronization, and collaborative features. Enhance team productivity.

```text
Add Google Workspace integration for document management,
calendar sync, and collaboration features
```

--------------------------------

### Requesting additional logging for debugging

Source: https://docs.leap.new/best-practices/debugging

This snippet shows how to ask Leap to add console.log statements to help gather more information about an error, facilitating a more precise diagnosis.

```text
When I submit the form, I get the error "TypeError: handleSubmit is not defined".  
Please add relevant console.log statements around the submit handler so I can gather more details.
```

--------------------------------

### Connect PostgreSQL Database

Source: https://docs.leap.new/integrations/import-databases

Leap allows integration with PostgreSQL databases using a connection string. This feature enables automatic schema reading and generation of full-stack applications based on existing data models. Supported providers include AWS RDS PostgreSQL, Google Cloud SQL, Prisma Postgres, Supabase, and Neon.

```text
Provide your PostgreSQL connection string to import your existing database. You can do this either in the prompt area when creating a new app, or in the **Infrastructure** view within an existing app, by clicking **Connect database** in the **External databases** section.
```

--------------------------------

### Leap's token optimization strategies

Source: https://docs.leap.new/best-practices/tokens

This section outlines Leap's internal strategies for optimizing token usage, including focusing on relevant chat and change history within the current 'Change' and controlling AI output to prioritize functional and efficient code generation.

```English
We’re always working to make Leap consume tokens in the most efficient way, and are investing heavily in building smart logic and advanced tools for optimizing what context is passed to the AI and have it produce only relevant output. This already includes strategies like:
  * Only including relevant chat history and change history from the current open **Change** , not all historical context.
  * Controlling the AI output and focusing it on writing functional and efficient code.
```

--------------------------------

### DataDog APM and Logging

Source: https://docs.leap.new/integrations/other

Integrate DataDog for application performance monitoring, logs, and custom metrics dashboards.

```python
Integrate DataDog for application performance monitoring,
logs, and custom metrics dashboards
```

--------------------------------

### Add CNAME Record in Namecheap

Source: https://docs.leap.new/deployment/custom-domains

Instructions for adding a CNAME record in Namecheap to point a subdomain to your Leap application. It details the steps within the Namecheap interface, including specifying the Type, Host, and Value.

```text
Type: CNAME Record
Host: Enter your subdomain (e.g., `api` for `api.your-domain.com`)
Value: `custom-domain.encr.app`
TTL: Automatic
```

--------------------------------

### Connect AWS Account via Encore Cloud

Source: https://docs.leap.new/deployment/aws

This section outlines the process of connecting your AWS account to Encore Cloud to deploy your Leap application. It involves accessing the Encore Cloud dashboard, creating a new IAM Role in AWS with specific trust relationships and permissions, and then connecting this role back to Encore Cloud by providing its ARN and verifying the external ID. Finally, you select the AWS region for deployment.

```bash
1. Go to the Encore Cloud dashboard
2. Select your application
3. Navigate to **App Settings** → **Integrations** → **Connect Cloud**
4. Select **Amazon Web Services (AWS)**
```

```bash
Follow the detailed instructions provided on the Connect Cloud page to:
  * Create a new IAM Role in your AWS account
  * Configure the trust relationship with Encore Cloud
  * Attach the necessary permissions for infrastructure provisioning

**Security requirement** : Make sure to check **“Require external ID”** and specify the external ID provided in the Encore Cloud instructions. This is critical for security.
```

```bash
Back in Encore Cloud:
  * Enter the ARN of the IAM role you created
  * Verify the external ID matches what you configured
  * Test the connection to ensure Encore can assume the role
```

```bash
Select which AWS region you want Encore Cloud to provision resources in:
  * Consider latency to your users
  * Review AWS region capabilities and compliance requirements
  * Factor in your existing AWS infrastructure location
```

--------------------------------

### Clerk Integration for User Management

Source: https://docs.leap.new/integrations/other

Add Clerk for comprehensive user management, including authentication, user profiles, and organization features. Simplify user onboarding and management.

```text
Add Clerk for complete user management with authentication,
user profiles, and organization features
```

--------------------------------

### SaaS Stack Integration Combination

Source: https://docs.leap.new/integrations/other

A popular integration combination for complete SaaS functionality, including Stripe for payments, Resend for email, PostHog for analytics, and Supabase for backend services.

```text
Stripe + Resend + PostHog + Supabase for complete SaaS functionality
```

--------------------------------

### AWS Infrastructure Provisioned by Encore Cloud

Source: https://docs.leap.new/deployment/aws

When deploying a Leap application through Encore Cloud to your AWS account, Encore automatically provisions various AWS services. This includes container-based compute resources with auto-scaling and load balancing, managed database services like Amazon RDS, production-ready networking and security configurations (VPC, security groups, SSL/TLS), and monitoring/logging integrations with CloudWatch and Encore's dashboard.

```text
Compute Resources
**Container-based application hosting**
  * AWS services appropriate for your application architecture
  * Auto-scaling based on demand
  * Load balancing for high availability
  * Security groups with proper network isolation
```

```text
Database Infrastructure
**Managed database services**
  * Amazon RDS for PostgreSQL (or your configured database)
  * Automated backups and maintenance
  * Multi-AZ deployment for production environments
  * Proper security configuration and access controls
```

```text
Networking & Security
**Production-ready network configuration**
  * VPC with appropriate subnet configuration
  * Security groups following least-privilege principles
  * SSL/TLS certificates for secure communication
  * IAM roles and policies for service access
```

```text
Monitoring & Logging
**Observability integration**
  * CloudWatch integration for metrics and logs
  * Integration with Encore’s monitoring dashboard
  * Alerting configuration for critical events
  * Performance monitoring and optimization insights
```

--------------------------------

### How Leap consumes tokens

Source: https://docs.leap.new/best-practices/tokens

This snippet details the three primary ways Leap consumes tokens: through messages exchanged between the user and the AI, the AI generating new code, and the AI analyzing the existing codebase and recent changes.

```English
Tokens are consumed in three main ways when using Leap:
  * Messages between you and the AI.
  * The AI writing new code for your application.
  * The AI reading and analyzing your existing codebase, including any changes you’ve made.
```

--------------------------------

### Sentry Error Tracking and Monitoring

Source: https://docs.leap.new/integrations/other

Add Sentry for error tracking, performance monitoring, and release health with custom context.

```python
Add Sentry for error tracking, performance monitoring,
and release health with custom context
```
Tokens:
Raw