Grade Calculator — DevLevelUp

Select a role to assess

Rate your skill proficiency — the system will calculate your recommended grade

Role

Skills Self-Assessment

Role: Database Engineer / DBA

Assessed: 0 Total: 0

AI Coding Assistants 1

▼

Uses GitHub Copilot for writing SQL queries and DBA scripts: SELECT/JOIN autocompletion, CREATE TABLE generation. Verifies suggested code for data type correctness and constraints.

Applies Copilot for DBA tasks: generating stored procedures, triggers, migration scripts. Uses AI for writing monitoring queries (Performance Schema, pg_stat_statements). Critically evaluates suggestions.

Effectively uses AI tools for complex DBA tasks: query optimization, partition strategy generation, writing backup/recovery scripts. Defines AI applicability boundaries for database administration.

Defines AI tooling standards for the DBA team: guidelines for code review of AI-generated SQL, restrictions for production scripts. Implements AI-assisted query optimization and anomaly detection in workflows.

Alerting & On-Call 1

▼

Understands basic database SLIs: query latency (p50, p99), availability (uptime), error rate. Monitors SLIs via dashboards. Participates in incident response when database service SLOs are violated.

Defines SLI/SLO for database services: query latency budgets, connection availability, replication lag thresholds. Configures SLO-based alerts: error budget burn rate, latency degradation. Participates in SLO review.

Designs SLI/SLO framework for the database tier: multi-tier SLO (critical vs standard databases), SLI by operation type (read vs write latency). Implements error budget policies and automated remediation on SLO breach.

Defines SLO standards for the data platform: SLO templates by DB tier, escalation policies, SLO review cadence. Coordinates SLO agreements between DBA and product teams. Establishes database reliability targets.

Algorithms & Data Structures 1

▼

Understands the fundamentals of Algorithms & Complexity at a basic level. Applies simple concepts in work tasks using SQL/Python. Follows recommendations from senior developers when solving problems.

Independently applies algorithmic thinking in database work: evaluates query execution plans, understands index algorithm selection for different workloads, selects appropriate sorting strategies for large result sets. Analyzes computational complexity of stored procedures and complex queries.

Applies algorithmic expertise to database internals: query optimizer algorithm understanding, index selection algorithms for workload optimization, partitioning algorithms for data distribution. Designs efficient data migration algorithms minimizing downtime and lock contention in production databases.

Defines algorithmic efficiency standards for SQL queries and procedures. Reviews queries focusing on operation complexity: nested loops vs hash joins, cardinality estimation. Implements automated query plan analysis in CI.

CI/CD 1

▼

Understands CI/CD concepts for database work: build, test, deploy for database migrations and schema changes. Uses existing workflows for migration validation. Can add a step to an existing pipeline for database checks. Reads failed build logs for migration issues.

Designs CI/CD pipelines from scratch. Configures caching for faster builds. Uses matrix builds for testing across different versions. Sets up deployment pipelines (staging → production). Works with secrets and environment variables.

Designs CI/CD platform for multiple projects. Creates reusable workflows/templates. Optimizes build time at the organizational level. Configures security scanning in pipelines. Implements deployment strategies (blue-green, canary). Integrates with ArgoCD/FluxCD.

Containerization 1

▼

Runs DBMS in Docker for local development: MySQL, PostgreSQL, ClickHouse containers. Understands docker-compose for multi-container stacks (DB + monitoring). Maps volumes for persistent data storage.

Manages containerized databases: configuring resource limits (memory, CPU), persistent volumes, custom configurations via bind mounts. Creates Docker images for DBA tools (backup scripts, monitoring agents).

Designs container strategy for database workloads: stateful containers vs bare-metal, storage drivers for I/O-intensive loads. Optimizes Docker networking for replication. Determines when containers are suitable for production DBs.

Defines container standards for the database tier: base images for DBA tooling, security scanning policy, resource allocation guidelines. Coordinates Docker usage for dev/staging DB environments and DBA automation.

Data Modeling 1

▼

Performs simple migrations: ALTER TABLE for adding columns, Flyway/Liquibase for schema versioning. Follows team runbooks when applying migrations. Understands the importance of backward compatibility.

Independently manages database migrations across environments: designs zero-downtime schema changes using online DDL tools (pt-online-schema-change, gh-ost), implements blue-green migration strategies, and validates data integrity with checksums. Automates migration pipelines with CI/CD integration.

Designs zero-downtime migrations: online DDL, pt-online-schema-change/gh-ost for MySQL, logical replication for PostgreSQL. Plans rollback strategy for each migration. Automates migration testing in staging.

Defines migration standards: review process for DDL changes, automated backward compatibility check, approval workflow. Coordinates large migrations (sharding, engine changes) across teams with minimal impact.

Database Administration 2

▼

Performs routine database backups using native DBMS tools (pg_dump, mysqldump, RMAN). Verifies backup completeness and tests restore procedures in development environments. Follows established backup policies and rotation schedules. Documents backup and recovery steps.

Designs comprehensive backup strategies combining full, incremental, and continuous archiving (WAL, binlog). Implements automated backup verification with restore testing. Configures cross-region replication for disaster recovery. Optimizes backup performance and storage costs.

Designs enterprise-grade backup architectures for high-load multi-database environments. Implements automated DR failover with sub-minute RTO targets. Optimizes backup strategies for petabyte-scale databases using parallel backup, compression, and deduplication. Leads DR exercises.

Defines organization-wide database backup and disaster recovery strategy aligned with business continuity objectives. Establishes backup standards, compliance frameworks, and recovery SLAs. Reviews and approves DR architectures across teams. Drives adoption of modern backup technologies.

Understands replication fundamentals: primary-replica setup, WAL shipping, binary log replication, and basic failover concepts. Monitors replication lag and replica status using built-in database tools. Follows documented procedures for replica provisioning and connection management.

Configures and manages database replication topologies: primary-replica, multi-source, and cascading replication. Optimizes replication performance through parallel apply, filtering, and conflict resolution. Implements automated failover with tools like Patroni, Orchestrator, or native HA solutions.

Designs enterprise replication architectures: multi-region active-active setups, conflict resolution strategies, and zero-downtime migration plans. Optimizes replication for high-throughput OLTP and mixed workloads. Architects disaster recovery with automated failover, RPO/RTO guarantees, and regular DR drills.

Defines data strategy at the product level. Establishes Replication and High Availability standards. Conducts data schema and scaling strategy reviews.

Database Optimization 2

▼

Creates basic indexes: B-tree for WHERE and JOIN, understands the difference between clustered and non-clustered. Uses EXPLAIN to detect missing indexes. Knows about index scan vs table scan.

Designs efficient indexes: composite indexes with correct column order, covering indexes to avoid lookups. Analyzes index usage statistics, finds unused and duplicate indexes for optimization.

Designs indexing strategy for high-load: partial indexes, expression indexes, GIN/GiST for specialized types. Performs online index creation without locks. Balances read performance vs write overhead.

Defines indexing standards: guidelines for index types by workload, automated index recommendations (pg_qualstats, sys.dm_db_index_usage_stats). Implements periodic index audits in operational processes.

Analyzes simple queries via EXPLAIN: understands Seq Scan, Index Scan, Nested Loop. Fixes obvious issues: missing indexes, SELECT * on large tables. Uses slow query log to find problematic queries.

Optimizes complex queries: refactoring subqueries to JOINs, eliminating N+1, using CTEs. Works with query profiling (EXPLAIN ANALYZE, Performance Schema). Understands statistics impact and query planner tuning.

Designs query optimization workflow: automated slow query detection, query plan regression testing, performance baselines. Optimizes at the architectural level: materialized views, denormalization, read replicas for offloading.

Defines query performance standards: response time SLA by tier, automated query review in CI, performance budgets. Coordinates optimization between DBA and development teams. Implements query governance.

Git & Workflows 1

▼

Uses Git for versioning database artifacts: migration scripts, stored procedures, configurations. Understands branch/merge workflow. Commits schema changes with descriptive messages.

Manages database code in Git: branching strategy for migration scripts, merge conflict resolution in SQL files. Configures Git hooks for SQL linting. Organizes repository structure for database projects.

Designs Git workflow for database changes: trunk-based development for migrations, feature branches for schema experiments. Automates: pre-commit hooks for SQL validation, automated changelog generation.

Defines Git standards for database artifacts: repository structure, branching policy, commit conventions for DDL changes. Coordinates version control practices between DBA and development teams.

Incident Management 1

▼

Participates in on-call rotation for the database tier: follows runbooks for alerts (high CPU, disk space, replication lag), escalates complex issues. Documents incidents and performs basic remediation actions.

Handles database incidents independently: diagnosing deadlocks, query performance degradation, replication breaks. Writes and updates runbooks. Conducts post-incident reviews for database-related incidents.

Designs on-call processes for the DBA team: alert routing by severity, escalation policies, runbook automation. Mentors junior DBAs in incident response. Implements automated remediation for common database issues.

Defines on-call standards for the database tier: rotation schedule, coverage requirements, alert fatigue reduction. Coordinates cross-team incident response. Conducts on-call retrospectives and improves processes.

Infrastructure Security 1

▼

Uses HashiCorp Vault for obtaining database credentials: dynamic secrets for DB connections, rotation policies. Understands basic secrets management concepts. Follows team procedures for credential handling.

Configures Vault database secrets engine: dynamic credentials for MySQL/PostgreSQL, automatic rotation, TTL policies. Manages database-specific roles and policies. Integrates Vault with connection poolers.

Designs secrets management for the database tier: Vault database engine for all DBMSes, automated credential rotation, emergency revocation procedures. Configures audit logging for database access via Vault.

Defines secrets management standards for the data platform: Vault policies for different database environments, rotation schedules, access review processes. Coordinates Vault integration with the database provisioning pipeline.

Logging 1

▼

Understands structured logging for database operations: JSON format for DBA scripts, mandatory fields (timestamp, db_name, operation). Uses structured logs for troubleshooting database issues.

Implements structured logging in DBA tools: unified format for backup/restore scripts, migration logs, maintenance operations. Configures correlation IDs for tracking database operations through the pipeline.

Designs structured logging standard for the database tier: schema for different operations (DDL, DML audit, replication events), contextual fields (query_hash, execution_plan). Integrates with the observability platform.

Defines logging standards for all database operations: mandatory fields, severity classification, PII masking for query parameters. Coordinates logging practices between DBA and application teams.

NoSQL Databases 3

▼

Executes analytical queries in ClickHouse: SELECT with GROUP BY, datetime filtering, basic aggregations. Understands columnar storage and MergeTree engine. Loads data from CSV and via INSERT.

Administers ClickHouse: configuring MergeTree partitioning, TTL for retention, materialized views for aggregation. Optimizes queries via EXPLAIN PIPELINE. Configures system table monitoring.

Designs ClickHouse clusters: ReplicatedMergeTree, distributed tables, sharding. Optimizes schema design for DBA analytics: query logs, slow query analysis, performance trends. Configures backup and disaster recovery.

Defines ClickHouse standards: naming conventions, partitioning strategy, retention policies. Coordinates ClickHouse usage for centralized storage of database metrics, audit logs, query analytics.

Understands MongoDB architecture, document storage model, and basic administration commands. Performs routine backup operations and monitors database health using built-in tools. Follows documentation and senior guidance for user management, index creation, and basic troubleshooting.

Independently designs MongoDB schemas optimized for application query patterns and data access. Understands aggregation pipelines, index strategies, and query execution plans using explain output. Configures replica sets, manages user roles, and performs capacity planning for growing datasets.

Designs MongoDB database architecture for high-load production systems with complex access patterns. Optimizes performance through advanced indexing, query profiling, and write concern tuning. Configures multi-node replication topologies and implements sharding strategies based on data distribution analysis.

Defines MongoDB data strategy at the product level including storage architecture and migration planning. Establishes database standards for schema design, indexing policies, and operational procedures. Conducts data architecture reviews and defines scaling strategies for multi-terabyte deployments across environments.

Optimization 1

▼

Monitors basic database performance metrics such as query execution time, buffer pool hit ratio, and connection counts. Can run EXPLAIN on slow queries and interpret simple query plans. Understands the purpose of VACUUM and ANALYZE operations and follows runbooks for routine maintenance tasks including index rebuilds and statistics updates.

Tunes buffer pool size, connection pool parameters, and write-ahead log configuration for production workloads. Performs detailed query plan analysis to eliminate inefficient joins, sequential scans, and suboptimal index usage. Configures automated vacuum schedules and analyzes replication lag to ensure read replicas stay within acceptable thresholds for application SLAs.

Designs comprehensive database performance architectures including partitioning schemes, tiered storage strategies, and advanced replication topologies. Masters buffer pool internals, page eviction policies, and OS-level tuning for I/O-bound workloads. Implements proactive performance anomaly detection, capacity planning models, and conducts root cause analysis for complex multi-node performance degradations.

Defines Database Performance Tuning strategy at team/product level. Establishes standards and best practices. Conducts reviews.

Relational Databases 1

▼

Works with PostgreSQL: creating tables with constraints, basic queries, psql CLI. Understands data types (JSONB, arrays), sequences, schemas. Can use EXPLAIN ANALYZE for simple query analysis.

Administers PostgreSQL: configuring shared_buffers, work_mem, effective_cache_size. Works with pg_stat_statements for load analysis, configures PgBouncer for connection pooling. Performs VACUUM and REINDEX operations.

Designs PostgreSQL HA: streaming replication, Patroni for automated failover, logical replication for zero-downtime migrations. Optimizes: partitioning, partial indexes, parallel queries. Configures PITR via WAL archiving.

Defines PostgreSQL standards: configuration templates by tier, monitoring checklists, backup/recovery SLA. Conducts capacity planning, plans major version upgrades. Coordinates PostgreSQL best practices across teams.

System Design 1

▼

Technical Documentation 2

▼

Understands the basics of architecture documentation approaches such as C4 model and arc42. Can read and interpret existing architecture diagrams and decision records. Follows established documentation templates and guidelines when contributing to database architecture docs. Documents simple schema changes and data flow diagrams under supervision.

Documents database architecture: ER diagrams, table and relationship descriptions, data flow diagrams. Maintains documentation for database configurations, backup procedures, connection details per environment.

Creates comprehensive database documentation: architecture decision records for DBMS selection, capacity planning documents, disaster recovery plans. Documents replication topology and failover procedures.

Defines database documentation standards: templates for database architecture docs, runbooks, data dictionaries. Coordinates documentation-as-code approach for database artifacts. Conducts documentation reviews.

Follows existing DBA runbooks: backup/restore procedures, failover steps, common troubleshooting. Documents steps when performing routine operations. Updates runbooks with found discrepancies.

Writes DBA runbooks: procedures for database maintenance (vacuum, reindex, partition management), incident response for common issues (replication lag, connection exhaustion). Includes diagnostic queries and remediation steps.

Designs runbook framework for the DBA team: standardized templates, automated runbooks via scripts, monitoring alert integration. Implements executable runbooks for automating common database operations.

Defines runbook standards: mandatory sections, testing requirements, regular review cadence. Coordinates runbook creation for new database services. Implements runbook automation via ChatOps and incident management tools.

Additional skills (optional) 34

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 SQL queries, explaining execution plans, and finding solutions to common database problems.

Effectively applies LLMs for DBA tasks: generating optimized queries, analyzing execution plans, creating migration scripts, automating routine database maintenance operations.

Uses AI for complex DBA tasks: analyzing load patterns from logs, generating indexing strategies, writing complex stored procedures, automating capacity planning.

Defines AI adoption strategy for the DBA team: standards for LLM-based SQL review, automating runbook generation, AI-assisted incident diagnostics.

Algorithms & Data Structures

▼

Understands basic database data structures: table schemas, primary/foreign key relationships, basic index types. Follows team conventions for naming tables and columns, writing simple queries using proper join structures.

Independently selects appropriate data structures for database design: proper index types for query patterns, partitioning strategies for large tables, JSON vs relational structures for semi-structured data. Understands trade-offs between normalization levels for different workload types.

Selects optimal data structures for database internals: B-tree vs hash index strategies, covering indices for query optimization, partitioning schemes for time-series and archival data. Optimizes table structures considering storage engine specifics (InnoDB page layout, PostgreSQL TOAST). Designs efficient schema structures for high-throughput OLTP and analytical workloads.

Defines data modeling standards: normalization vs denormalization for different workloads, table partitioning strategies. Reviews index structures, partitioning schemes, and storage strategies for OLTP and OLAP workloads.

Application Security

▼

Knows main OWASP Top 10 vulnerability categories, especially SQL injection. Understands basic database protection principles: parameterized queries, least privilege.

Applies OWASP principles for database protection: configuring row-level security, encrypting sensitive data, access auditing. Performs regular privilege analysis and removes excessive permissions.

Designs comprehensive database security: TDE for data encryption, dynamic masking, SQL injection detection at WAF level, anomalous access pattern monitoring.

Defines data security policy: data classification standards, access audit processes, security incident response, GDPR/PCI-DSS compliance at the DBMS level.

Knows basic secure coding principles: avoiding SQL injection, input validation. Applies parameterized queries and least privilege when working with databases.

Writes secure DBA scripts: parameterizing all queries, protecting against injection in dynamic SQL, secure credential storage, logging with sensitive data masking.

Designs secure DBA tools: Vault integration for secret management, backup encryption, audit trail for all administrative operations, automated password rotation.

Defines secure development standards for the DBA team: mandatory security review of scripts, privilege management processes, stored procedure vulnerability auditing.

Benchmarking

▼

Understands fundamentals of database benchmarking tools like sysbench, pgbench, and HammerDB. Runs basic benchmark suites to measure query throughput and latency. Follows team guidelines for configuring benchmark parameters and collecting baseline performance metrics.

Independently designs database benchmark suites simulating real-world workload patterns. Configures TPC-C, TPC-H, and custom benchmarks for capacity planning. Analyzes benchmark results to identify bottlenecks in query execution, I/O subsystem, and connection pooling configurations.

Designs enterprise-level database benchmarking strategies for capacity planning and architecture decisions. Creates custom workload simulations reflecting production traffic patterns with realistic data distributions. Establishes benchmarking standards and automated regression detection. Mentors team on performance analysis methodology.

Defines organization-wide database benchmarking strategy and performance standards. Establishes benchmark-driven decision-making processes for database technology selection and scaling planning. Conducts reviews of benchmark methodology ensuring statistical rigor and production relevance across teams.

Caching

▼

Understands caching principles and Redis purpose. Knows how cache interacts with the database: cache-aside, write-through, TTL. Understands the impact of cache on database load.

Configures Redis as a cache for database offloading: defining caching strategies (cache-aside/write-behind), configuring TTL, monitoring hit rate. Ensures cache-database consistency.

Designs caching strategies for database offloading: multi-level cache (L1 app / L2 Redis / L3 DB), invalidation on updates, Redis Cluster for high-load scenarios.

Defines caching architecture for the data platform: cache-invalidation standards, cache layer monitoring and alerting, warm-up strategies after restart, Redis capacity planning.

Clean Code & Refactoring

▼

Understands basic code quality principles for database scripts and stored procedures. Follows team naming conventions for tables, columns, and SQL formatting standards. Writes simple, clean migration scripts and basic stored procedures. Accepts code review feedback on query structure and naming consistency.

Independently applies code quality practices in database development. Writes well-structured stored procedures and migration scripts with proper naming and documentation. Understands trade-offs between query optimization and code maintainability. Reviews database code for index usage, transaction isolation, and naming consistency.

Designs code quality standards for database code: stored procedure conventions, migration script structure, schema change review processes. Refactors complex SQL procedures for performance and readability. Implements automated quality checks for query plans, index usage, and naming consistency.

Establishes SQL and DBA script quality standards: SQL linting (sqlfluff), code review for migrations, unit tests for stored procedures. Implements automated review for DDL changes and backward compatibility checks.

Cloud Providers

▼

Works with AWS database services: RDS for managed databases, S3 for backup storage, CloudWatch for basic monitoring. Understands IAM roles for database access, VPC and security groups for network isolation.

Administers AWS database services: RDS Multi-AZ, Aurora replicas, ElastiCache. Configures Parameter Groups, automated snapshots, Performance Insights. Optimizes costs via Reserved Instances for the database tier.

Designs AWS database architecture: Aurora Global Database for multi-region, DynamoDB for specific workloads, cross-account database access. Configures AWS Backup, Database Migration Service. Automates via CDK/Lambda.

Defines AWS database strategy: choosing between RDS, Aurora, self-managed EC2 by workload. Establishes cost management for the database tier, backup policies. Coordinates cloud database operations between DBA and DevOps teams.

Code Review

▼

Participates in SQL code and migration reviews: checks syntax, data types, naming conventions. Learns to find potential issues in schemas. Asks questions and follows feedback from senior DBA.

Conducts database change reviews: evaluates migrations for backward compatibility, checks index strategy, analyzes query performance impact. Verifies rollback plans for each DDL change.

Conducts deep database architecture review: evaluating data model decisions, partitioning strategy, replication impact. Mentors through review: explains normalization trade-offs, index design. Automates SQL review checks.

Defines database code review standards: mandatory checklists for DDL/DML changes, automated checks (backward compat, performance regression), approval workflows for production schema changes.

Concurrency & Parallelism

▼

Understands asynchronous execution concepts: callbacks, promises, event loop. Uses async calls when writing monitoring scripts and DBA task automation.

Applies asynchronous programming for DBA tasks: parallel monitoring of multiple DB instances, non-blocking backup operations, concurrent maintenance script execution.

Designs asynchronous systems for database management: parallel migration execution across multiple instances, async monitoring alert processing, concurrent metric collection from all nodes.

Defines async processing patterns for the DBA platform: strategies for parallel cluster maintenance, distributed operation coordination, timeout and retry handling for long-running tasks.

Understands multithreading concepts: threads, locks, race conditions. Knows how concurrent database access creates problems: deadlocks, contention, transaction isolation levels.

Diagnoses and resolves concurrent database access issues: deadlock analysis, transaction isolation level configuration, lock contention optimization. Configures connection pooling.

Designs concurrent access strategies for high-load databases: optimistic vs pessimistic locking, MVCC tuning, partitioning to reduce contention, advisory locks for coordination.

Defines concurrent data access standards: isolation level recommendations for different workloads, deadlock resolution policies, architectural patterns for high-concurrency.

Data Modeling

▼

Designs simple schemas: normalization up to 3NF, data type selection, constraints (NOT NULL, UNIQUE, FK). Creates ER diagrams for small modules. Understands the difference between OLTP and OLAP modeling.

Designs production schemas: choosing between normalization and denormalization by workload, partitioning strategy, data archiving. Considers growth patterns when selecting data types and partition keys.

Designs data models for high-load systems: sharding with data distribution awareness, temporal tables, polymorphic associations. Defines schema evolution strategy: backward compatible changes, expand-and-contract pattern.

Defines data modeling standards: naming conventions, data types per DBMS, partitioning guidelines. Conducts design reviews for critical schemas. Coordinates data modeling practices between product and DBA teams.

Database Optimization

▼

Understands fundamentals of database transactions, ACID properties, and isolation levels. Monitors active transactions and identifies basic locking issues. Follows team guidelines for configuring transaction log settings, managing lock timeouts, and troubleshooting simple deadlock scenarios.

Independently manages transaction behavior across database systems, tuning isolation levels for specific workload patterns. Diagnoses and resolves deadlocks using execution plans and lock monitoring tools. Implements advisory locks, two-phase commits, and transaction log management for high-throughput environments.

Designs transaction strategies for high-load distributed database systems with cross-shard consistency requirements. Implements advanced concurrency control mechanisms including MVCC tuning, serializable snapshot isolation, and distributed transactions. Optimizes transaction log performance for write-heavy workloads. Mentors team on transaction design.

Defines organization-wide transaction management standards and concurrency control policies across database platforms. Establishes guidelines for isolation level selection, distributed transaction patterns, and performance budgets for transaction processing. Conducts reviews of critical transaction designs ensuring data integrity at scale.

Infrastructure as Code

▼

Uses Terraform for provisioning DB infrastructure: RDS instances, parameter groups, subnet groups. Understands plan/apply workflow. Reads existing modules for database resources. Follows team IaC practices.

Writes Terraform modules for database provisioning: RDS/Aurora clusters, replicas, automated backups. Manages state for database resources. Configures parameter groups and security groups via IaC.

Designs IaC for the database platform: reusable modules for different DBMSes (MySQL, PostgreSQL, ClickHouse), composition patterns. Automates database infrastructure drift detection. Implements blue-green for database upgrades via Terraform.

Defines IaC standards for the database tier: module registry for DB resources, change management for stateful infrastructure. Implements policy-as-code for database security (encryption, network isolation). Coordinates Terraform adoption for DBA.

Integration Testing

▼

Understands the role of integration testing when working with databases. Writes basic tests to verify correct application-database interaction after migrations.

Develops integration tests for DBA operations: testing migrations on production data copies, failover scenario testing, replication and data consistency validation.

Designs integration test environments for databases: automated test cluster deployment, disaster recovery scenario testing, load testing migrations on realistic data.

Defines integration testing standards for the DBA team: mandatory scenarios before DBMS upgrades, application compatibility testing, pre-production validation processes.

Kubernetes & Orchestration

▼

Understands basic Kubernetes concepts for running database workloads in containers. Follows team guidelines for connecting to database pods, checking persistent volume claims, and viewing database operator logs. Uses existing configurations for StatefulSet-based database deployments.

Manages databases in Kubernetes: configuring StatefulSets with persistent storage, anti-affinity for replica distribution, Helm charts for DBMS cluster deployment.

Designs K8s infrastructure for databases: operators for management automation (CrunchyData, Vitess), backup strategies to cloud storage, storage class configuration for performance.

Defines database-on-Kubernetes strategy: criteria for K8s vs bare-metal, operator standards, zero-downtime DBMS upgrade processes, disaster recovery in containerized environments.

Logging

▼

Uses ELK for database log analysis: searching errors in Kibana, filtering by error level, database name. Understands MySQL/PostgreSQL log structure. Finds slow queries and connection errors via Elasticsearch.

Configures ELK for database observability: Filebeat for DB log collection, Logstash pipelines for slow query log parsing, structured logging. Creates Kibana dashboards for monitoring errors, deadlocks, replication events.

Designs database log analytics on ELK: centralized log collection from all DBMSes, correlation between query logs and system events. Configures alerting on anomalies: unusual error rates, replication breaks, auth failures.

Defines database logging standards: mandatory fields, retention policies, log levels. Coordinates ELK integration with the database monitoring stack. Implements log-based alerting for critical database events.

Metrics & Monitoring

▼

Understands how custom database metrics like query latency, replication lag, and connection pool usage are collected. Monitors predefined metric dashboards and escalates anomalies to senior engineers.

Configures custom database health metrics including slow query rates, index efficiency, and storage growth trends. Creates Grafana dashboards with alerts for replication lag and deadlock frequency. Participates in on-call rotation.

Designs observability strategy with business metrics. Implements distributed tracing. Defines SLI/SLO. Conducts post-mortems.

Defines custom metrics standards for the database tier: business-level metrics (orders/sec, active users), database-specific (replication slot lag, vacuum progress). Coordinates custom metrics implementation between DBA and dev teams.

Uses Grafana for DB monitoring: reading dashboards with metrics (connections, QPS, replication lag). Understands basic MySQL/PostgreSQL exporter metrics. Sets up simple threshold-based alerts.

Configures Prometheus monitoring for databases: mysqld_exporter, postgres_exporter, custom queries for business metrics. Creates Grafana dashboards: query performance, buffer pool hit ratio, lock waits. Configures alerting rules.

Designs database monitoring platform on Prometheus/Grafana: multi-database monitoring, custom exporters for specific metrics, recording rules for aggregation. Implements SLI-based alerting for database services.

Defines database monitoring standards: mandatory DBMS metrics, dashboard templates, alerting severity levels. Coordinates monitoring between DBA and SRE. Implements monitoring as part of database provisioning.

Networking

▼

Understands basic networking concepts: TCP/IP, DNS, ports. Knows networking aspects of database work: connection strings, DBMS ports, basic network connectivity diagnostics.

Applies networking knowledge to DBA tasks: configuring pg_hba.conf and firewall rules, diagnosing connection latency, optimizing TCP keep-alive for stable DB connections.

Designs network infrastructure for databases: network segmentation for the database tier, SSL/TLS for connection encryption, network tuning optimization for cross-datacenter replication.

Defines network architecture for the data platform: network segmentation standards, VPN/PrivateLink for cross-region replication, access policies and network anomaly monitoring.

NewSQL Databases

▼

NoSQL Databases

▼

Performs basic Cassandra cluster health checks using nodetool. Understands replication factors and consistency levels at a conceptual level. Executes routine maintenance tasks like repairs and compactions under guidance.

Designs table schemas balancing partition size and read performance in Cassandra. Configures compaction strategies and manages tombstone accumulation. Monitors cluster metrics and resolves hotspot and latency issues.

Architects Cassandra clusters for high-availability across multiple datacenters. Designs replication and sharding strategies for petabyte-scale systems. Leads capacity planning, disaster recovery procedures, and performance tuning at scale.

Defines data strategy at the product level. Establishes Apache Cassandra standards. Conducts data schema and scaling strategy reviews.

OOP & Design Patterns

▼

Knows fundamental design patterns: Singleton, Observer, Factory. Understands how patterns apply when creating DBA tools and database automation scripts.

Applies design patterns in DBA tools: Repository for DBMS metadata access, Strategy for different backup strategies, Observer for database event monitoring.

Designs DBA tools using advanced patterns: Chain of Responsibility for alert escalation, State Machine for database lifecycle management, Decorator for query auditing.

Defines a pattern catalog for the DBA platform: standard solutions for monitoring, failover, backup/restore. Mentors the team on applying patterns in database administration context.

Knows core OOP principles: encapsulation, inheritance, polymorphism. Applies basic patterns when writing automation scripts for database management.

Applies OOP when developing DBA tools: connection wrapper classes, abstractions for different DBMSes (PostgreSQL/MySQL/Oracle), patterns for migration scripts.

Designs object models for DBA tools: class hierarchies for different DBMS types, connection strategies, polymorphic handlers for monitoring different data stores.

Defines architectural standards for DBA tooling: DBMS abstraction patterns, extensibility principles for new storage systems, code review criteria for automation scripts.

Profiling

▼

Monitors database CPU utilization: identifies high-CPU queries via slow query log and top/htop. Understands the relationship between CPU and query complexity. Uses SHOW PROCESSLIST to find active heavy queries.

Profiles database CPU usage: pt-query-digest for MySQL, pg_stat_statements for PostgreSQL, wait events analysis. Identifies CPU-bound queries and optimizes them. Configures CPU-related alerts.

Designs CPU performance strategy for the database tier: workload classification (OLTP vs OLAP), CPU affinity for critical databases, connection pool tuning for optimal CPU usage. Implements automated query throttling.

Defines CPU performance standards: baseline metrics, alert thresholds, capacity planning. Coordinates CPU optimization between DBA and infrastructure teams. Implements performance testing in the database change pipeline.

Understands basic disk I/O metrics (IOPS, throughput, latency) and their impact on database performance. Uses OS-level tools like iostat and iotop to observe storage activity. Follows team guidelines for identifying I/O-heavy queries and tablespace layout recommendations.

Independently profiles database I/O patterns using pg_stat_io, dm_io_virtual_file_stats, or innodb_metrics. Correlates disk throughput and IOPS with query execution plans. Optimizes tablespace placement, WAL configuration, and buffer pool sizing to reduce I/O bottlenecks in OLTP and OLAP workloads.

Designs I/O profiling strategies for production database clusters on SSD, NVMe, and networked storage. Implements monitoring of read/write amplification, checkpoint I/O spikes, and replication lag from disk contention. Mentors DBAs on correlating storage metrics with query performance degradation.

Defines I/O profiling strategy and storage performance standards across database teams. Establishes dashboards tracking IOPS saturation, latency percentiles, and write amplification. Conducts reviews of storage tier selection and backup I/O impact. Drives I/O-aware query scheduling practices.

Prompt Engineering

▼

Understands basic principles of working with AI models. Formulates prompts to LLMs for help with SQL queries, finding database error causes, and generating documentation.

Applies prompt engineering for DBA tasks: structured SQL generation, execution plan analysis via AI, creating runbooks for typical incidents with specific DBMS context.

Uses advanced prompt engineering for DBA: automatic indexing strategy generation based on workload, AI analysis of slow query logs, test data generation from schemas.

Defines AI strategy for the DBA team: standard prompts for routine tasks, knowledge bases for contextual queries, AI integration into incident response and capacity planning processes.

Relational Databases

▼

Performs basic MySQL operations: creating tables, writing SELECT/INSERT/UPDATE queries, working with mysql CLI. Understands data types, PRIMARY KEY, FOREIGN KEY. Can read EXPLAIN and find full table scans.

Administers MySQL in production: configuring innodb_buffer_pool_size, query cache, slow query log. Works with master-slave replication, configures monitoring via Performance Schema. Optimizes queries through profiling.

Designs MySQL architecture for high-load: InnoDB cluster, Group Replication, ProxySQL for connection pooling and read/write splitting. Performs online DDL, pt-online-schema-change. Configures PITR and automated failover.

Defines organizational MySQL standards: versioning, configuration baselines, upgrade procedures. Coordinates zero-downtime major version migrations. Establishes MySQL infrastructure SLA and DR plans.

REST API

▼

Knows basic REST API principles: resources, HTTP methods, response codes. Understands how applications interact with the database through APIs and what access patterns this creates.

Designs REST APIs for DBA administrative tasks: endpoints for DB health monitoring, backup management, query statistics viewing. Considers security and authentication.

Develops REST APIs for the database management platform: provisioning automation, cluster management, API for self-service migrations. Ensures idempotency for critical operations.

Defines API standards for DBA team tools: unified contracts for monitoring, configuration management, auditing. Designs an API gateway for unified access to different DBMSes.

System Design

▼

Understands basic architectural concepts of Disaster Recovery Design. Follows team's architectural decisions. Understands main patterns.

Participates in DR processes: performs backup verification, tests restore procedures per runbooks. Configures automated snapshots and cross-region backup copying. Monitors replication lag and backup status.

Designs DR for the database tier: multi-region replication, automated failover (Patroni, MHA), backup verification through automated restores. Defines RPO/RTO for different tiers. Conducts DR drills.

Defines DR standards for the data platform: RPO/RTO by tier, DR testing schedule, failover procedures. Coordinates DR drills with cross-functional teams. Creates incident playbooks for database failures.

Understands basic system design concepts. Knows the database's role in application architecture: access patterns, load characteristics, consistency requirements.

Applies system design principles when planning DB infrastructure: choosing DBMS type, defining availability requirements, designing replication and backup schemes.

Designs data architecture for complex systems: distributed transactions, CQRS, event sourcing. Defines sharding, partitioning, and consistency strategies for high-load.

Defines data architecture for products: polyglot storage (SQL + NoSQL + Cache), scaling strategies, multi-region architecture for global applications with low latency.

Unit Testing

▼

Understands unit testing principles and its role in quality assurance. Writes basic tests for migration scripts and stored procedures, verifying data transformation correctness.

Develops unit tests for DBA scripts: testing migrations on a test DB, validating stored procedures with mock data, verifying ETL transformation and trigger correctness.

Designs testing frameworks for database work: automated test environment creation, data factories for generating realistic data, regression tests for query performance.

Defines testing strategy for the DBA team: coverage standards for migrations, mandatory smoke tests after deployment, test integration into the DB CI/CD pipeline.