Database Sharding

Understands sharding in Java context: knows how DataSource routing works in Spring, distinguishes logical and physical sharding. Can work with applications on ShardingSphere or custom routing without deep internals understanding.

Understands sharding concept in Node.js: knows how to connect to multiple DBs via different connection strings, understands shard key routing principle. Can work with applications using sharded MongoDB (native sharding).

Understands sharding in PHP context: knows why data needs to be split across multiple DB servers, can connect to different databases in Laravel/Symfony. Understands the main limitations of sharding for PHP applications.

Understands database sharding concept: knows why horizontal data partitioning is needed, difference between vertical and horizontal sharding. Can work with applications using sharded databases, executing queries against specific shards.

Understands sharding in the Rust context: knows how to manage multiple database connections through sqlx or diesel, understands shard key selection principles. Can work with Rust applications using multiple database pools.

Understands sharding in Scala ecosystem: knows how Akka Cluster Sharding works for in-memory data, distinguishes database sharding and actor sharding. Can work with Slick/Quill with multiple database configurations.

Works with sharding in Java: implements AbstractRoutingDataSource for multi-database routing, uses ShardingSphere for transparent sharding, configures HikariCP connection pools per shard. Applies thread-local context for shard selection in Spring transactions.

Works with sharded databases in Node.js: implements application-level sharding with Knex/Prisma via dynamic connection selection, configures MongoDB sharding with shard key selection, applies connection pooling per shard. Handles cross-shard queries via Promise.all scatter-gather.

Works with sharding in PHP: implements multi-tenant database routing in Laravel via database resolver, configures Doctrine DBAL with multiple connections, applies shard selection middleware. Uses ProxySQL for transparent routing at DB level.

Works with sharded databases in Python: uses Django database routers for multi-database routing, implements shard selection logic based on tenant_id or user_id. Understands sharding trade-offs: cross-shard queries, join limitations, data distribution skew.

Implements sharding in Rust: creates shard-aware connection pool manager, implements consistent hashing with jump hash or rendezvous hashing, handles cross-shard queries through async scatter-gather with tokio. Uses Rust type system for compile-time shard routing safety.

Works with sharding in Scala: implements database routing through custom Slick DatabaseProvider, uses Akka Cluster Sharding for distributed entity management. Applies functional programming patterns (Reader monad) for shard-aware data access.

Designs sharding for Java microservices: configures ShardingSphere with custom sharding algorithms, implements distributed transactions via XA or eventual consistency patterns, designs global tables for reference data. Optimizes cross-shard pagination and sorting.

Designs sharding for Node.js services: implements custom sharding proxy via Node.js streams, configures PostgreSQL sharding via Citus extension, designs resharding pipelines with Node.js worker threads. Optimizes connection management for high shard count with pgBouncer.

Designs sharding strategy for PHP systems: implements consistent hashing for shard distribution, designs resharding with zero-downtime via dual-write pattern, configures Vitess for transparent MySQL sharding. Solves cross-shard reporting problems via materialized views or ETL.

Designs sharding strategy for Python systems: selects shard key considering access patterns and data distribution, implements consistent hashing for balancing, designs cross-shard query aggregation. Configures Vitess or ProxySQL for transparent PostgreSQL/MySQL sharding.

Designs high-performance sharding in Rust: implements custom sharding proxy with zero-copy routing, optimizes connection management through connection pooling with async traits, designs online resharding through dual-write with async verification. Benchmarks shard router performance.

Designs sharding for Scala microservices: integrates Akka Cluster Sharding with persistent storage, implements cross-shard queries through Akka Streams, configures Cassandra data modeling with partition key design for natural sharding. Optimizes data locality for co-located processing.

Standardizes sharding in Java ecosystem: chooses between ShardingSphere, Vitess, and application-level sharding, designs online resharding pipelines with Spring Batch, implements shard health monitoring and alerting. Creates internal frameworks for standardizing sharding patterns.

Defines sharding strategy for Node.js platform: standardizes sharding patterns via npm packages, designs monitoring and alerting for shard health, develops automated testing for sharded scenarios. Defines data placement strategy considering Node.js event loop model.

Standardizes sharding in the PHP ecosystem: creates Composer packages for standard sharding setup, designs migration tools for per-shard schema management, implements monitoring for shard health and balance. Defines resharding strategy for growing PHP projects.

Defines sharding strategy at platform level: designs resharding procedures with zero-downtime, implements shard health and data distribution monitoring, standardizes cross-shard consistency approaches. Determines when sharding is necessary vs other scaling approaches.

Defines sharding strategy for Rust platform: creates internal sharding crate with pluggable strategies and monitoring, designs distributed transaction coordination through 2PC or saga. Standardizes testing for sharded scenarios through TestContainers and property-based tests.

Standardizes sharding in Scala ecosystem: defines when to use Akka Cluster Sharding vs database-native sharding, designs data placement strategy for distributed Scala systems. Creates abstractions for transparent sharding with type-safe shard key definitions.

Shapes enterprise data sharding strategy: designs multi-tier sharding (application sharding + database sharding), defines architecture for global-scale Java systems with sharding. Influences choice between ShardingSphere, Vitess, CockroachDB and Google Spanner for different use cases.

Shapes data architecture for large-scale Node.js systems: determines when application-level sharding vs database-native sharding (Citus, Vitess, MongoDB), designs multi-region data placement. Influences architectural decisions on data layer choice for petabyte-scale Node.js applications.

Shapes data architecture for large-scale PHP systems: determines when to shard vs migrate to distributed database, designs hybrid architecture (sharded MySQL + Redis cluster + Elasticsearch). Influences long-term data storage strategy considering PHP limitations.

Shapes data architecture strategy with sharding: designs multi-region sharding with geo-routing, defines approaches for data locality and compliance (GDPR). Influences choice between application-level sharding, database-native sharding (Citus, Vitess), and NewSQL (CockroachDB, TiDB).

Shapes Rust data layer architecture for extreme-scale systems: designs custom distributed database layer with sharding, defines trade-offs between consistency and performance for different shard topologies. Influences open-source Rust database ecosystem through contributions to foundationdb-rs, tikv and similar projects.

Shapes data architecture for distributed Scala systems: designs multi-layer sharding (Akka Cluster + database + geographic), defines consistency model for cross-shard operations. Influences architectural decisions on adopting distributed databases (Cassandra, CockroachDB) vs custom sharding in Scala.