CPU: if the app is CPU-bound (hashing, parsing, heavy logic), profile and optimize hot paths; consider more cores or a faster runtime. Database: slow queries, missing indexes, or connection exhaustion. Fix with indexes, query optimization, connection pooling, and read replicas. I/O: disk or network. Use async I/O, caching, or faster storage. External APIs: latency or rate limits. Cache responses, use timeouts, and consider async or background jobs.

Measure first: use APM, profiling, and metrics (latency percentiles, throughput, error rate) to find the real bottleneck before optimizing.

Horizontal scaling means adding more instances (servers, containers) and distributing load. Load balancer sends each request to one instance. To scale horizontally, the app must be stateless: no in-memory session or state that only one instance has. Store session in Redis or a DB, or use stateless auth (e.g. JWT). Then you can add instances and the load balancer will spread traffic.

Database can be the limit: many app instances hitting one DB. Use read replicas for read-heavy workloads and connection pooling (e.g. PgBouncer) to avoid exhausting connections.

Caching (in-memory or Redis) reduces DB and API load. Cache read-heavy, slowly changing data; invalidate or TTL when it changes. Async processing: move slow or non-urgent work to queues (e.g. send email, generate report). The request returns quickly; a worker processes the job. This improves latency and lets you scale workers independently.

Use CDN for static assets; use edge caching for API responses when appropriate (e.g. public, cacheable GET).