Agent skill

lambda-optimization-advisor

Reviews AWS Lambda functions for performance, memory configuration, and cost optimization. Activates when users write Lambda handlers or discuss Lambda performance.

View SKILL.md on GitHub Repository
Stars 232
Forks 15

Install this agent skill to your Project

npx add-skill https://github.com/aiskillstore/marketplace/tree/main/skills/emillindfors/lambda-optimization-advisor

SKILL.md

Lambda Optimization Advisor Skill

You are an expert at optimizing AWS Lambda functions written in Rust. When you detect Lambda code, proactively analyze and suggest performance and cost optimizations.

When to Activate

Activate when you notice:

  • Lambda handler functions using lambda_runtime
  • Sequential async operations that could be concurrent
  • Missing resource initialization patterns
  • Questions about Lambda performance or cold starts
  • Cargo.toml configurations for Lambda deployments

Optimization Checklist

1. Concurrent Operations

What to Look For: Sequential async operations

Bad Pattern:

rust
async fn handler(event: LambdaEvent<Request>) -> Result<Response, Error> {
    // ❌ Sequential: takes 3+ seconds total
    let user = fetch_user(&event.payload.user_id).await?;
    let posts = fetch_posts(&event.payload.user_id).await?;
    let comments = fetch_comments(&event.payload.user_id).await?;

    Ok(Response { user, posts, comments })
}

Good Pattern:

rust
async fn handler(event: LambdaEvent<Request>) -> Result<Response, Error> {
    // ✅ Concurrent: all three requests happen simultaneously
    let (user, posts, comments) = tokio::try_join!(
        fetch_user(&event.payload.user_id),
        fetch_posts(&event.payload.user_id),
        fetch_comments(&event.payload.user_id),
    )?;

    Ok(Response { user, posts, comments })
}

Suggestion: Use tokio::join! or tokio::try_join! for concurrent operations. This can reduce execution time by 3-5x for I/O-bound workloads.

2. Resource Initialization

What to Look For: Creating clients inside the handler

Bad Pattern:

rust
async fn handler(event: LambdaEvent<Request>) -> Result<Response, Error> {
    // ❌ Creates new client for every invocation
    let client = reqwest::Client::new();
    let data = client.get("https://api.example.com").await?;
    Ok(Response { data })
}

Good Pattern:

rust
use std::sync::OnceLock;

// ✅ Initialized once per container (reused across invocations)
static HTTP_CLIENT: OnceLock<reqwest::Client> = OnceLock::new();

async fn handler(event: LambdaEvent<Request>) -> Result<Response, Error> {
    let client = HTTP_CLIENT.get_or_init(|| {
        reqwest::Client::builder()
            .timeout(Duration::from_secs(10))
            .build()
            .unwrap()
    });

    let data = client.get("https://api.example.com").await?;
    Ok(Response { data })
}

Suggestion: Use OnceLock for expensive resources (HTTP clients, database pools, AWS SDK clients) that should be initialized once and reused.

3. Binary Size Optimization

What to Look For: Missing release profile optimizations

Check Cargo.toml:

toml
[profile.release]
opt-level = 'z'     # ✅ Optimize for size
lto = true          # ✅ Link-time optimization
codegen-units = 1   # ✅ Better optimization
strip = true        # ✅ Strip symbols
panic = 'abort'     # ✅ Smaller panic handler

Suggestion: Configure release profile for smaller binaries. Smaller binaries = faster cold starts and lower storage costs.

4. ARM64 (Graviton2) Usage

What to Look For: Building for x86_64 only

Build Command:

bash
# ✅ Build for ARM64 (20% better price/performance)
cargo lambda build --release --arm64

Suggestion: Use ARM64 for 20% better price/performance and often faster cold starts.

5. Memory Configuration

What to Look For: Default memory settings

Guidelines:

bash
# Test different memory configs
cargo lambda deploy --memory 512   # For simple functions
cargo lambda deploy --memory 1024  # For standard workloads
cargo lambda deploy --memory 2048  # For CPU-intensive tasks

Suggestion: Lambda allocates CPU proportionally to memory. For CPU-bound tasks, increasing memory can reduce execution time and total cost.

Cost Optimization Patterns

Pattern 1: Batch Processing

rust
async fn handler(event: LambdaEvent<Vec<Item>>) -> Result<(), Error> {
    // Process multiple items in one invocation
    let futures = event.payload.iter().map(|item| process_item(item));
    futures::future::try_join_all(futures).await?;
    Ok(())
}

Pattern 2: Early Return

rust
async fn handler(event: LambdaEvent<Request>) -> Result<Response, Error> {
    // ✅ Validate early, fail fast
    if event.payload.user_id.is_empty() {
        return Err(Error::from("user_id required"));
    }

    // Expensive operations only if validation passes
    let user = fetch_user(&event.payload.user_id).await?;
    Ok(Response { user })
}

Your Approach

  1. Detect: Identify Lambda handler code
  2. Analyze: Check for concurrent operations, resource init, config
  3. Suggest: Provide specific optimizations with code examples
  4. Explain: Impact on performance and cost

Proactively suggest optimizations that will reduce Lambda execution time and costs.

Recommended Agent Skills

Expand your agent's capabilities with these related and highly-rated skills.

aiskillstore/marketplace

perigon-backend

Perigon ASP.NET Core + EF Core + Aspire conventions

232 15
Explore
aiskillstore/marketplace

perigon-agent

Pointers for Copilot/agents to apply Perigon conventions

232 15
Explore
aiskillstore/marketplace

perigon-angular

Angular 21+ standalone/Material/signal conventions for Perigon WebApp

232 15
Explore
aiskillstore/marketplace

fastapi-mastery

Comprehensive FastAPI development skill covering REST API creation, routing, request/response handling, validation, authentication, database integration, middleware, and deployment. Use when working with FastAPI projects, building APIs, implementing CRUD operations, setting up authentication/authorization, integrating databases (SQL/NoSQL), adding middleware, handling WebSockets, or deploying FastAPI applications. Triggered by requests involving .py files with FastAPI code, API endpoint creation, Pydantic models, or FastAPI-specific features.

232 15
Explore
aiskillstore/marketplace

context7-efficient

Token-efficient library documentation fetcher using Context7 MCP with 86.8% token savings through intelligent shell pipeline filtering. Fetches code examples, API references, and best practices for JavaScript, Python, Go, Rust, and other libraries. Use when users ask about library documentation, need code examples, want API usage patterns, are learning a new framework, need syntax reference, or troubleshooting with library-specific information. Triggers include questions like "Show me React hooks", "How do I use Prisma", "What's the Next.js routing syntax", or any request for library/framework documentation.

232 15
Explore
aiskillstore/marketplace

browser-use

Browser automation using Playwright MCP. Navigate websites, fill forms, click elements, take screenshots, and extract data. Use when tasks require web browsing, form submission, web scraping, UI testing, or any browser interaction.

232 15
Explore

Didn't find tool you were looking for?

Be as detailed as possible for better results