What metrics define performance success?

Key metrics include TTFB, FCP, LCP, FID, CLS, API p95, DB p95, and memory usage, complemented by user experience goals.

How does caching improve performance?

Caching serves data from faster layers (CDN, Redis, HTTP caches) to reduce latency; pair with valid invalidation strategies and appropriate TTLs.

What is the Performance Pyramid?

A layered view shown in the SKILL content that guides performance from infrastructure up to code optimization, infrastructure, design patterns, and caching.

performance

Scanned

skill

npx machina-cli add skill Fujigo-Software/f5-framework-claude/performance --openclaw

Files (1)

SKILL.md

4.5 KB

Performance Skills

Overview

Performance optimization knowledge for building fast, scalable applications that provide excellent user experience.

Key Metrics

Metric	Target	Description
TTFB	< 200ms	Time to First Byte
FCP	< 1.8s	First Contentful Paint
LCP	< 2.5s	Largest Contentful Paint
FID	< 100ms	First Input Delay
CLS	< 0.1	Cumulative Layout Shift
API Response	< 200ms	P95 response time
Database Query	< 50ms	P95 query time
Memory Usage	< 80%	Application memory threshold

Performance Pyramid

         ╱╲
        ╱  ╲         CDN / Edge
       ╱────╲
      ╱      ╲       Application Cache
     ╱────────╲
    ╱          ╲     Database Optimization
   ╱────────────╲
  ╱              ╲   Code Optimization
 ╱________________╲  Infrastructure

Quick Reference

Response Time Targets

Operation Type	Target	Maximum
Static assets	< 50ms	100ms
API read	< 100ms	200ms
API write	< 200ms	500ms
Search	< 200ms	500ms
Report generation	< 2s	5s
File upload	< 5s	30s

Caching Strategy by Data Type

Data Type	Cache Location	TTL
Static assets	CDN	1 year
User session	Redis	30 min
User profile	Redis	1 hour
Product catalog	Redis + CDN	6 hours
Search results	Redis	5 min
Config	Memory	24 hours

Skill Files

Fundamentals

Caching

Database

API

Frontend

Profiling

Scaling

Integration with F5 Framework

Quality Gate Integration

Performance requirements should be defined in quality gates:

# .f5/quality/gates-status.yaml
gates:
  G2:
    performance:
      api_p95_response: "< 200ms"
      database_p95_query: "< 50ms"
      memory_usage: "< 80%"

Traceability

Performance requirements should be traceable:

// NFR-PERF-001: API response time must be under 200ms at P95
export async function getUser(id: string): Promise<User> {
  // implementation
}

Source

git clone https://github.com/Fujigo-Software/f5-framework-claude/blob/main/plugins/f5-core/skills/performance/SKILL.mdView on GitHub

Overview

Delivers fast, scalable applications by applying proven performance techniques. It covers measurement, bottleneck analysis, caching, database and API tuning, and frontend optimizations to improve user experience.

How This Skill Works

Start by defining targets using the performance metric framework (TTFB, FCP, LCP, FID, CLS, API and DB timings) and reference figures from the Skill. Then apply category-specific strategies—caching, database tuning, API performance, frontend optimizations, profiling, and scaling—and validate improvements with benchmarking and monitoring.

When to Use It

You need to meet core Web Vitals and API latency targets in production (TTFB <200ms, LCP <2.5s, etc.)
You observe high p95 API or database query times and want to reduce latency
You’re addressing N+1 query issues or slow database performance
You’re deploying caching layers (CDN, Redis) and need effective invalidation and headers
You’re optimizing frontend deliverables (bundles, images, lazy loading) to improve Core Web Vitals

Quick Start

Step 1: Define performance targets (TTFB <200ms, LCP <2.5s, CLS <0.1) and capture a baseline
Step 2: Profile critical paths with CPU/memory analysis and APM to identify bottlenecks across backend, DB, API, and frontend
Step 3: Implement improvements (caching, DB tuning, compression, bundle optimization) and validate with tests

Best Practices

Measure with the standard metrics (TTFB, FCP, LCP, FID, CLS, API and DB timings) and monitor progress
Profile CPU and memory, using APM tools to pinpoint bottlenecks
Apply caching at the right layer (HTTP headers, CDN, Redis) with clear invalidation rules
Optimize database performance with indexing, query optimization, and connection pooling
Iterate frontend performance with bundle optimization, code splitting, lazy loading, and image optimization

Example Use Cases

CDN-enabled static assets and edge caching reduced TTFB to under 200ms
Redis caching and HTTP compression cut API read latency from 400ms to 120ms
Indexing and query rewriting eliminated N+1 queries and lowered p95 DB time
Code splitting and image optimization improved Core Web Vitals scores
Auto-scaling and load balancing kept memory usage under 80% during peak load