shield_lock
JinDaGe
← Back to skills
extension
Category: Development & EngineeringNo API key required

Load Balancing

Load balancing distributes traffic across multiple targets to improve

personAuthor: jakexiaohubgithub
open_in_newRepositorydownloadDownload package

Load Balancing

Skill Profile

(Select at least one profile to enable specific modules)

  • [ ] DevOps
  • [x] Backend
  • [ ] Frontend
  • [ ] AI-RAG
  • [ ] Security Critical

Overview

Load balancing distributes traffic across multiple targets to improve availability, performance, and resilience. This guide covers algorithms, health checks, session persistence, TLS termination, and operational best practices for implementing robust load balancing solutions.

Why This Matters

Load balancing is critical for modern applications because it:

  • Improves availability by eliminating single points of failure
  • Enhances performance by distributing load across healthy targets
  • Enables horizontal scaling to handle traffic spikes
  • Provides graceful degradation when targets fail
  • Supports zero-downtime deployments with connection draining
  • Enables global traffic distribution for multi-region deployments

Core Concepts & Rules

1. Core Principles

  • Follow established patterns and conventions
  • Maintain consistency across codebase
  • Document decisions and trade-offs

2. Implementation Guidelines

  • Start with the simplest viable solution
  • Iterate based on feedback and requirements
  • Test thoroughly before deployment

Inputs / Outputs / Contracts

Skill Composition

Quick Start / Implementation Example

  1. Review requirements and constraints
  2. Set up development environment
  3. Implement core functionality following patterns
  4. Write tests for critical paths
  5. Run tests and fix issues
  6. Document any deviations or decisions
# Example implementation following best practices
def example_function():
    # Your implementation here
    pass

Assumptions

  • Backend targets are healthy and responsive
  • Network connectivity between load balancer and targets
  • Sufficient capacity to handle expected traffic
  • Health check endpoints are implemented on all targets
  • TLS certificates are available for HTTPS

Compatibility & Prerequisites

  • Supported Versions:
    • Python 3.8+
    • Node.js 16+
    • Modern browsers (Chrome, Firefox, Safari, Edge)
  • Required AI Tools:
    • Code editor (VS Code recommended)
    • Testing framework appropriate for language
    • Version control (Git)
  • Dependencies:
    • Language-specific package manager
    • Build tools
    • Testing libraries
  • Environment Setup:
    • .env.example keys: API_KEY, DATABASE_URL (no values)

Test Scenario Matrix (QA Strategy)

| Type | Focus Area | Required Scenarios / Mocks | | :--- | :--- | :--- | | Unit | Core Logic | Must cover primary logic and at least 3 edge/error cases. Target minimum 80% coverage | | Integration | DB / API | All external API calls or database connections must be mocked during unit tests | | E2E | User Journey | Critical user flows to test | | Performance | Latency / Load | Benchmark requirements | | Security | Vuln / Auth | SAST/DAST or dependency audit | | Frontend | UX / A11y | Accessibility checklist (WCAG), Performance Budget (Lighthouse score) |

Technical Guardrails & Security Threat Model

1. Security & Privacy (Threat Model)

  • Top Threats: Injection attacks, authentication bypass, data exposure
  • [ ] Data Handling: Sanitize all user inputs to prevent Injection attacks. Never log raw PII
  • [ ] Secrets Management: No hardcoded API keys. Use Env Vars/Secrets Manager
  • [ ] Authorization: Validate user permissions before state changes

2. Performance & Resources

  • [ ] Execution Efficiency: Consider time complexity for algorithms
  • [ ] Memory Management: Use streams/pagination for large data
  • [ ] Resource Cleanup: Close DB connections/file handlers in finally blocks

3. Architecture & Scalability

  • [ ] Design Pattern: Follow SOLID principles, use Dependency Injection
  • [ ] Modularity: Decouple logic from UI/Frameworks

4. Observability & Reliability

  • [ ] Logging Standards: Structured JSON, include trace IDs request_id
  • [ ] Metrics: Track error_rate, latency, queue_depth
  • [ ] Error Handling: Standardized error codes, no bare except
  • [ ] Observability Artifacts:
    • Log Fields: timestamp, level, message, request_id
    • Metrics: request_count, error_count, response_time
    • Dashboards/Alerts: High Error Rate > 5%

Agent Directives

When configuring load balancers:

  1. Always validate configuration before applying
  2. Test health checks against all targets
  3. Monitor distribution after changes
  4. Implement gradual rollouts for major changes
  5. Have rollback plans ready
  6. Document all changes with clear reasons

Definition of Done (DoD) Checklist

  • [ ] Tests passed + coverage met
  • [ ] Lint/Typecheck passed
  • [ ] Logging/Metrics/Trace implemented
  • [ ] Security checks passed
  • [ ] Documentation/Changelog updated
  • [ ] Accessibility/Performance requirements met (if frontend)

Anti-patterns

  1. No health checks: Always implement health checks
  2. Ignoring uneven distribution: Monitor and address distribution issues
  3. Overusing sticky sessions: Only use when necessary
  4. Single point of failure: Always have redundancy
  5. Ignoring TLS: Always use HTTPS in production
  6. No monitoring: Without monitoring, you can't detect issues

Reference Links & Examples

  • Internal documentation and examples
  • Official documentation and best practices
  • Community resources and discussions

Versioning & Changelog

  • Version: 1.0.0
  • Changelog:
    • 2026-02-22: Initial version with complete template structure