These skills do not affect the main grade but show the breadth of your profile.
AI Coding Assistants
▼
Familiar with AI assistants ChatGPT and Claude. Uses them for generating test scenarios, writing load scripts, and analyzing performance test results.
Effectively applies LLMs for performance tasks: generating JMeter/Gatling scripts from scenario descriptions, analyzing bottlenecks from metrics, creating reports with optimization recommendations.
Uses AI for complex performance testing tasks: automatic analysis of degradation graphs, metric correlation for root cause analysis, generating predictive models for capacity planning.
Defines AI adoption strategy for the performance team: standard prompts for result analysis, AI-assisted test planning, automatic executive report generation.
Familiar with AI-powered IDE Cursor and basic capabilities. Uses autocomplete to accelerate writing JMeter/Gatling/k6 test scripts and load test configurations.
Effectively applies Cursor for performance testing: generating test scripts from scenario descriptions, refactoring complex test scenarios, creating data-driven tests with AI assistance.
Uses advanced Cursor capabilities: custom rules for performance testing standards, AI-generated correlation rules, automatic creation of assertion libraries for metrics.
Standardizes AI-IDE usage in the performance team: prompt library for common scenarios, configurations for various load testing frameworks, team training.
API Management
▼
Understands the importance of documenting APIs and test scenarios. Can read API documentation to create correct test requests and validate responses in load tests.
Documents performance testing APIs and processes: test scenario descriptions, load parameters, metrics and thresholds. Creates runbooks for conducting standard performance tests.
Designs performance platform documentation: test scenario description standards, report templates, APIs for launching tests and retrieving results. Automates generation from code.
Defines documentation standards for the performance team: test plan templates, report formats, update policies. Implements docs-as-code for test documentation.
Uses performance testing tools: k6 for load tests, autocannon for HTTP benchmarks, Postman for functional validation. Understands results: latency percentiles, throughput.
Configures performance tools: k6 with custom metrics, Gatling for complex scenarios, distributed load generation. Creates reusable test libraries. Integrates with CI/CD.
Designs tooling strategy: k6 vs Gatling vs Locust selection by scenario, custom extensions for protocol support, distributed test orchestration.
Defines performance tooling standards: tool selection criteria, team training, shared libraries. Implements a performance testing CoE (Center of Excellence).
Application Security
▼
Knows main OWASP Top 10 vulnerability categories. Understands the relationship between security and performance: DDoS attacks, rate limiting, security middleware impact on latency.
Conducts security-oriented performance tests: stress-testing rate limiter and WAF, measuring TLS/encryption overhead, testing resilience against DDoS load patterns.
Designs tests at the intersection of security and performance: benchmarking impact of various security controls, testing AuthN/AuthZ under load, production-like security in test environments.
Defines security performance testing strategy: mandatory security overhead testing per release, standards for conducting load tests securely, compliance checks.
Knows basic secure coding principles: data validation, error handling. Applies secure practices when writing load testing scripts and processing results.
Writes secure performance testing scripts: protecting test credentials, secure storage of load configurations, masking sensitive data in test logs and reports.
Designs secure performance infrastructure: test environment isolation from production, secure handling of test data, audit trail for load tests, protection against accidental production impact.
Defines security standards for the performance team: test environment access policies, procedures for using production-like data, secure test infrastructure management.
Authentication & Authorization
▼
Understands JWT/OAuth2 basics for load testing: generating valid tokens for test scenarios, simulating authenticated user sessions at scale, and measuring authentication endpoint performance. Follows team practices for test environment token management and OAuth2 flow testing.
Configures authentication for performance tests: JWT token generation for virtual users, implementing OAuth flows in load scripts, testing token refresh under load.
Designs performance tests for AuthN/AuthZ: benchmarking identity provider under load, testing token validation latency, analyzing JWT verification overhead for high-RPS scenarios.
Defines authentication testing strategy: standard benchmarks for identity infrastructure, performance criteria, recommendations for optimizing the auth layer under load.
Benchmarking
▼
Uses benchmarking tools: k6 for HTTP, pgbench for PostgreSQL, fio for storage, iperf for network. Understands results: throughput, latency, IOPS.
Configures benchmarking: custom k6 extensions, JMH for Java micro-benchmarks, wrk2 for coordinated omission prevention. Creates repeatable benchmark suites.
Designs benchmarking framework: automated benchmark execution, statistical analysis (confidence intervals, outlier detection), regression detection. Custom benchmarks.
Defines benchmarking standards: tool selection criteria, execution procedures, result interpretation guidelines. Implements benchmark-driven development.
Understands performance budgets: latency targets per endpoint, memory limits per service, CPU budgets. Monitors budgets during testing.
Creates performance budgets: defines thresholds per service/endpoint, tracks budget consumption. Configures automated alerts on threshold violations. Correlates with business metrics.
Designs performance budget framework: hierarchical budgets (system → service → endpoint), automated enforcement in CI, trend analysis for early warning.
Defines performance budget standards: mandatory budgets per service, review process, exception handling. Coordinates budget allocation with product and engineering.
Caching
▼
Understands caching principles and how Redis works. Knows how caching affects system performance and which Redis metrics matter in performance testing.
Conducts performance testing of systems with Redis: measuring cache hit/miss ratio under load, Redis throughput benchmarks, testing system behavior with cold cache and cache stampede.
Designs comprehensive caching tests: modeling various cache warming strategies, testing Redis Cluster under load, analyzing the impact of eviction policies on performance.
Defines cache layer performance testing strategy: standard Redis benchmarks, degradation criteria, sizing recommendations. Consults on optimal caching strategies.
CI/CD
▼
Runs performance tests in CI: smoke tests per PR, baseline comparison. Reads CI results. Understands when a performance test fails.
Configures CI for performance: automated tests per build, threshold-based pass/fail, results archiving. Integrates k6/Gatling results with PR comments.
Designs CI performance pipeline: multi-stage testing (smoke → load → soak), automated regression detection, performance gate enforcement.
Defines CI performance standards: mandatory performance gates, threshold management, reporting. Implements continuous performance testing.
Clean Code & Refactoring
▼
Understands the fundamentals of Code Quality & Refactoring at a basic level. Applies simple concepts in work tasks using Python/Java. Follows recommendations from senior developers when solving problems.
Independently applies code quality practices in performance testing. Writes clean load test scripts with proper parameterization and correlation handling. Understands trade-offs between test script realism and maintainability. Reviews test scenarios for proper think times, assertion accuracy, and metric collection reliability.
Designs code quality standards for performance testing codebases: JMeter/Gatling/k6 script structure, load scenario modularity, result analysis automation. Refactors complex test scenarios for maintainability and parameterization. Establishes review practices for test reproducibility and metric correlation accuracy.
Establishes quality standards for test scripts: code review, version control, reusable libraries. Implements CI for test script validation. Defines naming conventions and documentation.
Concurrency & Parallelism
▼
Understands the fundamentals of Async Programming at a basic level. Applies simple concepts in work tasks using Python/Java. Follows recommendations from senior developers when solving problems.
Independently applies async programming in load testing: concurrent virtual user simulation, async request generation patterns, non-blocking result collection. Understands trade-offs between thread-based and event-driven load generation approaches.
Designs async architectures for load testing: high-concurrency virtual user simulation, async protocol-level request generation, non-blocking real-time metrics collection. Mentors team on async patterns for realistic load generation at scale.
Defines async standards: concurrent virtual users, async data collection, parallel test execution. Implements best practices for non-blocking test scripts.
Containerization
▼
Runs performance tools in Docker: k6, Grafana, InfluxDB for local testing. Understands container resource limits and their impact on test load.
Configures Docker for performance: containers for load generators, monitoring stack (Prometheus+Grafana), results in InfluxDB. Optimizes container resources.
Designs containerized performance infrastructure: distributed load generators, dynamic scaling test agents, isolated test environments. Optimizes container overhead.
Defines container standards for performance testing: test agent images, resource guidelines, environment provisioning. Implements container-based test infrastructure.
Database Optimization
▼
Analyzes index usage for performance: missing indexes via EXPLAIN, unused indexes via pg_stat_user_indexes. Understands the impact of indexes on read/write performance.
Profiles index performance: index scan vs seq scan analysis, index bloat detection, covering index effectiveness. Recommends optimizations based on load test results.
Designs index performance testing: automated index analysis during load tests, correlation between index changes and latency, A/B testing index strategies.
Defines indexing performance standards: mandatory analysis during performance testing, index efficiency metrics, review process for index changes.
Finds slow queries through load testing: top SQL by duration, execution count. Analyzes EXPLAIN plans. Recommends basic optimizations: indexes, query rewrite.
Profiles query performance: pg_stat_statements analysis, query plan changes under load, parameter sniffing issues. Correlates query performance with application latency.
Designs query performance testing: production query replay, parameterized workloads, regression detection. Optimizes: connection pool sizing, prepared statement caching.
Defines query performance standards: SLA per query type, mandatory profiling during load tests, automated regression alerting.
Distributed Tracing
▼
Uses tracing for performance analysis: finds slow spans, analyzes service dependencies. Understands trace waterfall for latency breakdown.
Configures OTel for performance: span-level timing, custom attributes for performance context, trace-based bottleneck detection. Integrates tracing with load tests.
Designs performance tracing: distributed trace analysis pipeline, automated bottleneck detection, trace-based capacity analysis. Optimizes OTel overhead.
Defines OTel performance standards: mandatory spans, performance-relevant attributes, trace analysis procedures. Implements trace-driven performance debugging.
Git & Workflows
▼
Works with Git for performance scripts: version control for k6/Gatling scenarios, test configs. Follows commit conventions. Writes descriptive commit messages.
Uses Git for performance projects: branch per test scenario, PR review for test scripts. Manages baseline configs, threshold files. Configures git hooks.
Defines Git strategy for performance: test script versioning, baseline management, CI integration. Configures branch protection for production test configs.
Builds Git workflow for the performance team: branching model, review requirements, CODEOWNERS for critical test scenarios.
GraphQL
▼
Understands basics of GraphQL query performance characteristics — N+1 problems, query depth impact, and resolver execution patterns. Writes simple load tests for GraphQL endpoints using tools like k6 or Artillery. Follows team guidelines for baseline performance benchmarking of GraphQL APIs.
Conducts GraphQL API performance testing: creating realistic queries of varying complexity, testing query depth limits, measuring latency for nested queries and batch operations.
Designs comprehensive GraphQL performance tests: resolver chain benchmarking, testing N+1 problems under load, measuring DataLoader overhead, stress-testing subscriptions.
Defines GraphQL performance testing strategy: standard benchmarks, query complexity criteria, optimization recommendations. Develops methodology for the development team.
Infrastructure as Code
▼
Understands Terraform basics for provisioning load testing infrastructure: test runner instances, target environments, monitoring dashboards. Can use existing configurations to spin up and tear down test environments. Follows IaC practices for reproducible test setups.
Uses Terraform for performance infrastructure: deploying load generators in the cloud, setting up test environments with required topology, managing resources for distributed load testing.
Designs Terraform modules for performance infrastructure: scalable load generator clusters, automated monitoring deployment, CI/CD integration for running tests.
Defines IaC strategy for the performance platform: reusable modules for various scenarios, cost management for test infrastructure, GitOps for environment management.
Integration Testing
▼
Understands the role of integration testing in the performance context. Knows how integration tests help identify performance bottlenecks at component boundaries.
Develops integration performance tests: testing end-to-end latency across service chains, verifying inter-service communication throughput, database bottleneck detection.
Designs comprehensive integration performance tests: modeling realistic traffic through all system layers, testing degradation during component failures, cascade failure scenarios.
Defines integration performance testing standards: mandatory scenarios per release, pass/fail criteria, escalation processes when component-level degradation is detected.
Kubernetes & Orchestration
▼
Runs performance tests in K8s: load generator pods, port-forwarding for target access. Monitors K8s metrics during tests. Reads pod logs for debugging.
Configures K8s for performance testing: Job resources for test runs, resource requests for consistent results. Monitors K8s cluster performance during tests.
Designs K8s-based performance infrastructure: distributed k6 operators, auto-scaling test agents, namespace isolation. Analyzes K8s overhead on test results.
Defines K8s standards for performance: test environment templates, resource policies, scheduling. Coordinates shared test infrastructure.
Logging
▼
Uses Kibana for performance analysis: filters logs by duration, searches for errors under load. Creates dashboards for test run monitoring.
Configures ELK for performance: log-based latency analysis, error rate tracking, custom dashboards for load test monitoring. Correlates logs with performance metrics.
Designs log-based performance analysis: structured performance logs, automated anomaly detection in logs, correlation with APM data. Optimizes log pipeline throughput.
Defines log-based performance standards: mandatory performance fields, analysis templates, retention for historical comparison.
Analyzes structured logs for performance: filters by duration, status code. Correlates log entries with test scenarios. Understands timing fields in logs.
Designs performance logging: timing fields (request_duration, db_query_time), resource usage context. Configures log-based alerting for performance degradation.
Designs performance logging architecture: high-resolution timing data, distributed trace correlation, sampling strategies for high-load logging.
Defines performance logging standards: mandatory timing fields, log-based SLI calculation, analysis procedures.
Metrics & Monitoring
▼
Creates custom performance metrics: business transaction latency, throughput per endpoint, error rate by type. Uses Prometheus client for application metrics.
Designs performance metrics: detailed latency breakdown (db, external, processing), resource efficiency metrics. Configures recording rules for aggregation.
Defines performance metrics framework: standard instrumentation, custom metrics for bottleneck detection, derived metrics for analysis. Implements automated anomaly detection.
Defines custom metrics standards for performance: mandatory instrumentation, naming conventions, cardinality budget. Implements a performance metrics catalog.
OOP & Design Patterns
▼
Knows fundamental design patterns: Factory, Strategy, Observer. Understands how patterns apply when creating test scripts and load generators in performance projects.
Applies patterns in load testing tools: Strategy for different load models (ramp-up, spike, soak), Builder for constructing scenarios, Observer for metric collection.
Designs performance frameworks using patterns: Pipeline for result processing, Composite for compound scenarios, Decorator for adding monitoring to test steps.
Defines architectural patterns for the performance platform: standard solutions for distributed load generation, scaling patterns for test infrastructure, reporting templates.
Understands the fundamentals of OOP & SOLID Principles at a basic level. Applies simple concepts in work tasks using Python/Java. Follows recommendations from senior developers when solving problems.
Independently applies OOP/SOLID in load testing frameworks: proper abstraction for virtual user scenarios, interface-based protocol handlers, single responsibility in data feeders and result collectors. Understands trade-offs between OOP patterns and DSL approaches in performance testing tool design.
Applies OOP/SOLID in performance testing framework architecture: abstract protocol interfaces for multi-protocol support, strategy pattern for load generation algorithms, template method for standardized test scenarios. Designs extensible load testing frameworks supporting multiple protocols and analysis backends.
Defines code standards for performance tests: modular test scripts, reusable components (Page Objects for load tests), abstract base classes for different protocols.
Optimization
▼
Analyzes latency: p50, p95, p99 percentiles per endpoint. Identifies slow paths through tracing. Understands contribution: network, app processing, DB.
Optimizes latency: bottleneck identification via distributed traces, latency breakdown analysis (app/DB/network). Tests optimizations: caching, connection reuse, async.
Designs latency optimization program: budget per service chain, tail latency analysis, automated regression detection. Implements latency SLO monitoring.
Defines latency standards: budgets per endpoint, regression policy, optimization tracking. Implements latency-driven development practices.
Prompt Engineering
▼
Understands basic principles of working with AI models. Formulates prompts to LLMs for help with writing test scripts, analyzing logs, and interpreting test results.
Applies prompt engineering for performance tasks: generating load scenarios from user stories, automated test result analysis, creating reports and optimization recommendations.
Uses advanced prompt engineering: chain-of-thought for root cause analysis from metrics, generating correlation reports, AI-assisted capacity planning based on metric trends.
Defines AI strategy for the performance team: standard prompts for common analyses, LLM integration into reporting, automating recommendation generation from test results.
REST API
▼
Tests API performance: baseline latency (p50, p95, p99), throughput (RPS), error rates. Uses Postman/curl for smoke tests. Understands HTTP keep-alive impact.
Designs API performance tests: realistic user scenarios, ramp-up patterns, peak load simulation. Tests: pagination performance, payload size impact, compression benefits.
Designs API performance testing strategy: production traffic modeling, dependency isolation (service virtualization), soak testing for memory leaks. Defines API performance SLA.
Defines API performance standards: mandatory performance testing per endpoint, SLA definitions, regression gates in CI. Coordinates performance requirements with product.
System Design
▼
Understands basic system design concepts: client-server, load balancers, caches, databases. Knows how system architecture affects its performance.
Applies system design knowledge when planning performance tests: identifying load points, modeling user workload, designing test environments that mimic production.
Designs performance tests for complex architectures: microservices, event-driven systems, distributed caching. Defines testing strategy for each architectural component.
Defines performance testing approaches for various architectural patterns: serverless, CQRS, event sourcing. Advises architects on performance implications of their decisions.
Type Systems
▼
Understands type safety concepts and their importance for code reliability. Uses typing when writing test scripts to prevent errors in load parameters.
Applies strict typing in performance scripts: TypeScript for k6 tests, typed load configurations, interfaces for test results and metrics, test parameter validation.
Designs type-safe performance frameworks: generic types for different testing protocols, compile-time test scenario validation, typed APIs for reporting.
Defines type safety standards for the performance team: mandatory script typing, type-safe configurations, code review criteria for preventing runtime errors in tests.
Unit Testing
▼
Understands unit testing principles and its role in quality assurance. Writes basic tests for utilities and helpers used in load testing scripts.
Develops unit tests for performance testing components: validating load generators, verifying metric parser correctness, testing custom plugins for JMeter/Gatling.
Designs test frameworks for performance tools: unit tests for custom protocol handlers, data generators, assertion libraries. Ensures test infrastructure reliability.
Defines testing standards for the load testing team: script coverage, mandatory tests for custom extensions, CI integration for validating test scenarios before execution.
Web Frameworks
▼
Uses Python Web Frameworks at a basic level in JMeter/Gatling/k6. Performs simple tasks using ready-made templates. Understands basic concepts and follows team practices.
Independently implements tasks with Python Web Frameworks in JMeter/Gatling/k6. Understands internal workings and optimizes performance. Writes load/stress/soak tests.
Develops performance testing tools on Python/FastAPI: results API, dashboard backends, automated reporting. Integrates with Locust for distributed load testing.
Defines tooling strategy: Python for Locust/custom tools, FastAPI for reporting API. Chooses between Python and Go/Java for high-throughput load generators.