Database Sharding and Partitioning Strategies for Globally Distributed Applications

Understanding Sharding and Partitioning

When you’re building applications that need to serve users all over the world, your database can quickly become a bottleneck. Sharding and partitioning are two key strategies to tackle this, essentially breaking down a large database into smaller, more manageable pieces. While often used interchangeably, it’s helpful to think of partitioning as dividing a single database, and sharding as distributing those divisions across multiple independent database instances. This distinction is crucial because sharding inherently deals with distributed systems, bringing both powerful scalability and significant architectural challenges.

The core idea behind both is to reduce the load on a single database server. By splitting data, you can distribute read and write operations across multiple machines, leading to better performance, higher availability, and improved fault tolerance. For globally distributed applications, this means you can potentially place data closer to your users, reducing latency and making the application feel snappier. Without these strategies, a single database might struggle to keep up with the sheer volume of global traffic, leading to slow response times and a poor user experience.

Why Go Distributed?

Globally distributed applications aren’t just about reaching a wider audience; they’re about resilience and speed. Imagine an e-commerce platform with customers in New York, London, and Tokyo. If all their data is stored in a single database server in, say, Virginia, users in Tokyo will experience significantly higher latency due to the physical distance. Distributing your data means you can serve local users from local data centers, drastically cutting down on network round-trip times.

Beyond performance, distribution also boosts fault tolerance. If one data center experiences an outage, other regions can continue to operate, minimizing downtime. This is particularly important for critical applications where even a few minutes of downtime can translate into significant financial losses or reputational damage. Regulatory compliance, such as GDPR or CCPA, also plays a role, sometimes requiring data to reside within specific geographical boundaries.

In exploring the complexities of database sharding and partitioning strategies for globally distributed applications, it is insightful to consider the lessons learned from the tech industry, particularly in the context of social media. A related article discusses the return of Instagram’s founders to the social media scene and the implications of their experiences on modern application architecture. For more information, you can read the article here: What We Can Learn from Instagram’s Founders’ Return to the Social Media Scene.

Key Takeaways

• The training data includes information and events up to October 2023.
• Insights and knowledge are based on a wide range of sources available until the cutoff date.
• No updates or developments occurring after October 2023 are included in the training.
• Users should verify current information from reliable sources for the latest updates.
• The model’s responses reflect the context and knowledge available up to the specified date.

Core Sharding Strategies

Choosing the right sharding strategy is fundamental, as it dictates how your data is distributed and how effectively you can scale. There’s no one-size-fits-all answer here; the best approach depends heavily on your application’s specific access patterns, data relationships, and growth projections.

Range-Based Sharding

Range-based sharding, as the name suggests, involves dividing data into ranges based on a specific column, often called the “shard key.” For example, you might shard users by their user_id range (e.g., IDs 1-10000 on Shard A, 10001-20000 on Shard B). Another common use case is sharding by geographical region or by time.

The appeal of range-based sharding is its simplicity in concept and implementation. Queries for a specific range of data are straightforward to route to the correct shard. It’s also relatively easy to add new shards as your data grows by simply defining new ranges. However, this strategy can lead to “hot spots” if data isn’t distributed evenly across the defined ranges. If a particular range receives a disproportionately high number of queries or writes (e.g., a specific popular product range, or a time range representing current events), that shard can become overloaded while others remain underutilized. Resharding (redistributing data when ranges need adjustment) can also be a complex and disruptive operation.

Hash-Based Sharding

Hash-based sharding uses a hash function applied to the shard key to determine which shard a piece of data belongs to. The hash function takes the shard key as input and outputs a hash value, which is then mapped to a specific shard. For instance, hash(user_id) % number_of_shards could determine the shard.

This approach generally provides a more even distribution of data across shards, reducing the likelihood of hot spots compared to range-based sharding. This makes it a good choice for scenarios where query patterns are unpredictable or highly varied. The downside is that range queries (e.g., “give me all users with IDs between X and Y”) become more complex, often requiring queries across all shards and then aggregation, which can be inefficient. Adding or removing shards with a simple modulo hash can also be problematic, as it typically requires recomputing the hash for all data, leading to a massive data migration. Consistent hashing is a technique used to mitigate this, making shard additions/removals less disruptive.

Directory-Based Sharding

Directory-based sharding employs a lookup table or a dedicated routing service that maintains a mapping between shard keys and their corresponding physical shards. When a query comes in, the application or a dedicated routing layer consults this directory to find the correct shard.

This method offers a lot of flexibility. Shard mappings can be changed dynamically, allowing for easy rebalancing of data, adding new shards, or migrating data between shards without significant disruption to the application. It also makes it easier to implement more complex sharding logic. The main drawback is the added overhead and potential single point of failure introduced by the directory service itself. The directory needs to be highly available and performant, as every data access depends on it. Managing and maintaining this metadata layer adds complexity to the overall system architecture.

Geo-Based Sharding (Geographical Sharding)

Geo-based sharding, often called “data locality sharding,” places data geographically closer to the users who access it most frequently. For example, all user data from Europe might reside in a European data center, while Asian user data is in an Asian data center.

The primary benefit here is dramatically reduced latency for users, as data travels shorter distances. It also simplifies compliance with regional data residency regulations. However, managing global consistency becomes a significant challenge.

If a user travels from Europe to Asia, their data might need to migrate, or queries might need to span regions, introducing cross-region latency.

Applications also need to carefully consider how to handle data that needs to be accessed globally, such as product catalogs or global settings, often leading to a hybrid approach where some data is replicated globally while other data is sharded geographically.

Entity-Based Sharding

Entity-based sharding (sometimes called client-specific or tenant-based sharding in multi-tenant systems) shards data based on a core entity, such as a customer, organization, or user. All data related to a single entity resides on the same shard. For example, in a multi-tenant SaaS application, all data for Tenant A would be on one shard, and all data for Tenant B on another.

This simplifies queries for a specific entity, as you only need to hit one shard. It also makes it easier to perform operations like backing up or restoring data for a specific entity. The challenges include potential hot spots if one entity is much larger or more active than others (the “noisy neighbor” problem). It also requires careful planning for how to handle data that crosses entity boundaries or global entities. Rebalancing can also be tricky if entities grow unevenly, often requiring moving entire entities to different shards.

Key Considerations for Globally Distributed Systems

Implementing sharding in a globally distributed context introduces a host of complexities that go beyond just splitting data. You’re now dealing with network latency, eventual consistency, and operational overhead on a much larger scale.

Data Consistency Models

In a distributed system, achieving strong consistency (where all replicas always show the most up-to-date data) can be extremely challenging and often comes at a high performance cost, especially across geographically dispersed data centers. This is where different consistency models come into play.

Eventual Consistency

Eventual consistency is a popular choice for globally distributed applications because it prioritizes availability and performance over immediate consistency.

The idea is that if no new updates are made to a given data item, eventually all accesses to that item will return the last updated value. In simple terms, updates propagate through the system “eventually.” This model works well for data where slight delays in seeing the latest updates are acceptable, such as social media feeds, product reviews, or user profiles. The trade-off is that during the propagation period, different users might see different versions of the data.

Managing this requires careful application design to handle stale reads and potential conflicts.

Strong Consistency

Strong consistency ensures that once an update is committed, all subsequent reads will see that update. This is the traditional model for single-node databases and is often preferred for financial transactions or inventory management where data accuracy is paramount. Achieving strong consistency across a distributed system, especially across regions, typically involves distributed consensus protocols (like Paxos or Raft) which can introduce significant latency due to the need for agreement among multiple nodes before committing a write.

This often means slower write operations and potentially reduced availability if parts of the system are unreachable.

Causal Consistency

Causal consistency is a middle-ground approach. It ensures that if one event causally affects another, then anyone who observes the second event will also observe the first. For example, if I comment on a post, and you then reply to my comment, causal consistency ensures that you see my comment before your reply.

However, two independent updates might not be ordered. It’s stronger than eventual consistency but weaker than strong consistency, providing a good balance for many distributed applications where a logical ordering of events is important but global strict ordering is not necessary.

Data Replication Strategies

Once you’ve decided on your consistency model, how you replicate your data becomes critical for both availability and read performance.

Master-Slave (Primary-Secondary) Replication

In master-slave replication, one instance (the master or primary) handles all write operations, and then replicates those changes to one or more slave (or secondary) instances. Slaves can handle read operations. If the master fails, one of the slaves can be promoted to master. This setup is common and relatively easy to understand.

It provides strong consistency on the master and can offer read scalability through slaves. The challenge is that all writes must go through a single master, which can become a bottleneck. Also, cross-regional master-slave setups introduce significant latency for writes if the master is far from the writer, and failover can lead to data loss if the master fails before replicating all transactions.

Multi-Master Replication

Multi-master replication allows multiple database instances to accept write operations.

Changes from each master are then replicated to the other masters. This offers higher write availability and improved write performance, especially across geographically distributed regions, as writes can be directed to the nearest master. However, it introduces significant challenges in conflict resolution.

If two masters simultaneously update the same piece of data, how do you decide which update wins? Implementing robust conflict resolution mechanisms (last write wins, custom logic, etc.) adds complexity and requires careful design to maintain data integrity.

Quorum-Based Replication

Quorum-based replication, often associated with eventually consistent systems, involves a specific number of replicas that must acknowledge a write (write quorum, W) and a specific number of replicas that must be queried for a read (read quorum, R). For consistency, the sum of W and R must be greater than the total number of replicas (N).

This ensures that there’s always at least one replica that has the most recent write. For example, if you have 5 replicas (N=5), and you set W=3 and R=3, then W+R=6 > N=5, guaranteeing that a read will always see the latest write. This provides a flexible way to tune the trade-offs between consistency, availability, and performance.

Handling Cross-Shard Transactions

One of the trickiest aspects of sharding is dealing with transactions that need to involve data residing on multiple shards.

In a traditional un-sharded database, a transaction is ACID (Atomic, Consistent, Isolated, Durable) and guarantees that either all changes are committed or none are. With sharding, this atomicity across shards is difficult to maintain.

Two-Phase Commit (2PC)

Two-Phase Commit (2PC) is a traditional protocol used to achieve atomic transactions across distributed databases. It involves a coordinator and multiple participants (the shards).

In the first phase (“prepare”), the coordinator asks all participants if they can commit the transaction. If all participants respond “yes,” the coordinator moves to the second phase (“commit”), instructing all participants to commit. If any participant says “no” or fails to respond, the coordinator instructs everyone to rollback.

While 2PC provides strong consistency, it comes with significant drawbacks in a globally distributed context.

It’s a blocking protocol, meaning participants hold locks during the entire process, which can lead to high latency and reduced availability, especially if network issues or failures occur between participants. A single failure can block the entire transaction. For these reasons, 2PC is often avoided in highly scaled, globally distributed systems where performance and availability are paramount.

Distributed Sagas

Distributed sagas are a pattern for managing long-running transactions across multiple services or shards without using 2PC.

Instead of one atomic transaction, a saga is a sequence of local transactions, where each local transaction updates data within a single service/shard and publishes an event that triggers the next step in the saga. If a step fails, the saga executes compensating transactions to undo the changes made by previous successful steps, effectively rolling back the entire distributed operation.

There are two main ways to implement sagas:

• Choreography: Each service/shard involved in the saga produces events that are consumed by other services, which then perform their local transactions and publish new events. This is decentralized but can be harder to monitor and debug.
• Orchestration: A central orchestrator service (saga coordinator) is responsible for dictating the order of operations and handling compensating actions if any step fails.

  This provides more control and visibility but introduces the orchestrator as a potential single point of failure (though the orchestrator itself can be made highly available).

Sagas offer better availability and scalability than 2PC but introduce eventual consistency and require careful design of compensating transactions. The application needs to be able to deal with intermediate states where some parts of the saga have committed and others haven’t, which can be complex.

Data Rebalancing and Maintenance

Sharding isn’t a “set it and forget it” solution. As your application grows and usage patterns change, you’ll inevitably need to adjust your sharding scheme. This process, often called rebalancing, is crucial for maintaining performance and avoiding hot spots.

Resharding Techniques

Resharding is the process of changing the number of shards or altering the shard key distribution. This can be one of the most challenging operational tasks in a sharded system.

Offline Resharding

Offline resharding involves taking the entire system (or at least the affected shards) offline, migrating data to the new shard configuration, and then bringing the system back online. This is the simplest approach but leads to significant downtime, which is often unacceptable for globally distributed applications that demand high availability. It might be feasible for smaller, internal systems or during planned maintenance windows with minimal impact.

Online Resharding (Live Migration)

Online resharding allows you to rebalance data without interrupting service. This is significantly more complex and typically involves a multi-phase process:

1. Preparation: New shards are provisioned, and the routing logic is updated to recognize the new configuration, but no data is moved yet.
2. Data Copying: Data from the old shards is gradually copied to the new shards. During this phase, both old and new shards might need to be kept in sync.
3. Dual Writes: During the copying phase, the application might write to both the old and new locations for data that is being migrated. This ensures that new writes are not lost.
4. Cutover: Once the data is copied and synchronized, a “cutover” event occurs where the routing logic is fully switched to point to the new shards.
5. Cleanup: Old shards are eventually decommissioned.

This process requires sophisticated tooling and careful coordination to ensure data consistency and minimal impact on application performance during the migration. Many managed database services offer capabilities to simplify online resharding.

Monitoring and Alerting

Effective monitoring is non-negotiable for sharded, globally distributed systems. You need to know what’s happening across all your shards, in all your regions, at all times.

Key Metrics to Track

• Shard-level performance: CPU utilization, memory usage, disk I/O, network throughput, query latency, connection counts for each individual shard. This helps identify hot spots or underperforming shards.
• Application-level metrics: End-to-end latency, error rates, request throughput, cache hit rates. These metrics show the user’s perspective.
• Replication lag: For replicated setups, monitoring the delay between primary and secondary instances is crucial to understand data freshness and potential data loss in case of failover.
• Cross-region latency: Latency between different data centers for database operations and application requests.
• Shard balancing: Metrics indicating the distribution of data and load across shards. Are some shards significantly larger or busier than others?
• Directory service health: If you’re using a directory-based sharding approach, the health and performance of that service are paramount.

Alerting Strategies

Set up alerts for deviations from normal operating parameters. Don’t just alert on critical failures; also alert on performance degradation, increasing error rates, or growing replication lag, which can be early indicators of larger problems. Integrate these alerts with your incident management systems to ensure prompt responses. A common strategy is to use thresholds that escalate severity based on duration or magnitude of the issue.

Backup and Disaster Recovery

A robust backup and disaster recovery (DR) strategy is more complex with sharded, globally distributed databases but also more critical.

Consistent Backups

Taking a consistent backup of a sharded database is challenging because individual shards might be backed up at different times, leading to an inconsistent state. Solutions include:

• Distributed snapshotting: Coordinating snapshots across all shards simultaneously, often by temporarily pausing writes or using logical clocks.
• Logical backups: Using tools that read data transactionally and reconstruct a consistent state.
• Continuous archiving: Shipping transaction logs (WALs) to a separate storage system, allowing point-in-time recovery.

Cross-Region Disaster Recovery

For global applications, DR means not just restoring data but restoring service in another region.

• Active-Passive DR: One region is primary, and another is a warm or hot standby. Data is replicated from primary to secondary. In a disaster, the secondary region is promoted. This is simpler but requires full data replication and potential failover time.
• Active-Active DR: All regions are active and can serve traffic. Data is replicated between all active regions (often using multi-master or quorum-based replication). This offers the highest availability and minimal downtime in a disaster, as traffic can be seamlessly redirected. However, it’s the most complex to implement and manage, particularly regarding conflict resolution and consistency.
• Recovery Point Objective (RPO) and Recovery Time Objective (RTO): Clearly define these for your application. RPO is the maximum acceptable amount of data loss (e.g., 5 minutes), and RTO is the maximum acceptable downtime (e.g., 30 minutes). These objectives will guide your choice of backup and DR strategies.

In the context of optimizing performance for globally distributed applications, understanding database sharding and partitioning strategies is crucial. These techniques can significantly enhance data management and retrieval speeds, ensuring that applications remain responsive even under heavy loads. For a broader perspective on how technology is transforming various sectors, you might find this article on how smartwatches are revolutionizing the workplace quite insightful. It highlights the impact of modern technology on efficiency and productivity, which parallels the benefits of effective database strategies. You can read more about it here.

Tools and Technologies

The landscape of databases and related tools for sharding and partitioning is vast and evolving. Here’s a look at some common approaches and technologies.

Relational Databases

Traditional relational databases (RDBMS) like PostgreSQL and MySQL are highly reliable and feature-rich. While they don’t natively offer automatic sharding out of the box, they can be effectively sharded with custom application logic or middleware.

PostgreSQL and MySQL Sharding

• Application-level sharding: The application layer is responsible for determining which shard to route a query to based on the shard key. This gives maximum control but places the complexity on the application developers.
• Proxy-based sharding: A database proxy layer sits between the application and the shards. The proxy intercepts queries, routes them to the correct shard, and can potentially aggregate results from multiple shards. Examples include Vitess (for MySQL), PgBouncer (for connection pooling, can be used with custom routing), or custom-built proxies.
• Foreign Data Wrappers (PostgreSQL): PostgreSQL’s FDWs allow you to query data in external data sources as if it were a local table. While not direct sharding, it can be used to create a “logical database” that spans multiple physical shards, simplifying queries from the application’s perspective.
• Table partitioning: Both PostgreSQL and MySQL support native table partitioning, which divides a single table into smaller, more manageable pieces within a single database instance. This is a form of partitioning, not sharding, and primarily helps with query performance, maintenance, and storage efficiency on a single server. It’s often used as a first step before considering full sharding across multiple instances.

NoSQL Databases

NoSQL databases were often designed from the ground up with distributed systems and horizontal scalability in mind, making them natural fits for sharding and partitioning.

Cassandra

Apache Cassandra is a highly scalable, high-availability, distributed NoSQL database. It’s designed for handling massive amounts of data across many commodity servers, providing high availability with no single point of failure. Cassandra uses a consistent hashing ring to distribute data across nodes. You define a primary key, and the first part of that key acts as the partition key, determining which node (or set of nodes) data resides on. It offers tunable consistency, allowing you to choose the trade-off between consistency and availability. Cassandra is particularly good for write-heavy workloads and scenarios requiring high availability across multiple data centers.

MongoDB

MongoDB is a document-oriented NoSQL database that offers native sharding capabilities. You define a shard key, and MongoDB’s sharding mechanism (a mongos router and config servers) automatically distributes data across a cluster of mongod instances (shards). The mongos router handles query routing and ensures that data is stored and retrieved from the correct shards. MongoDB supports different sharding strategies, including range-based and hash-based sharding. It’s well-suited for applications with evolving data schemas and high read/write volumes.

DynamoDB

Amazon DynamoDB is a fully managed, serverless NoSQL database service. It automatically handles sharding, replication, and scaling for you based on your provisioned throughput or on-demand capacity settings. You define a primary key (partition key, and optionally a sort key), and DynamoDB uses this to distribute data across its internal partitions. It offers single-digit millisecond performance at virtually any scale and high availability. Its managed nature significantly reduces operational overhead, but it comes with a vendor lock-in and a specific pricing model.

Managed Database Services

Cloud providers offer managed services that abstract away much of the complexity of sharding and partitioning, though the underlying principles remain the same.

Azure Cosmos DB

Azure Cosmos DB is a globally distributed, multi-model database service. It automatically replicates and shards your data across regions and partitions based on your chosen partition key. It offers multiple consistency models (ranging from strong to eventual) and guarantees low latency and high availability. Cosmos DB handles all the infrastructure management, scaling, and fault tolerance, allowing developers to focus on application logic.

Google Cloud Spanner

Google Cloud Spanner is a globally distributed, strongly consistent, relational database service. Unlike most other globally distributed databases that rely on eventual consistency or complex transaction management, Spanner provides external consistency (a stronger form of serializability) across its entire global deployment. It achieves this through atomic clocks and GPS, allowing for consistent reads across regions without sacrificing availability. Spanner handles automatic sharding and replication and is designed for applications requiring high availability and strong consistency at global scale.

In the context of optimizing performance for globally distributed applications, understanding database sharding and partitioning strategies is crucial. For those looking to explore innovative technology solutions, a related article discusses the potential of the Samsung Galaxy Chromebook 2 360, which highlights how advancements in hardware can complement software strategies. You can read more about it in this insightful piece here. This synergy between cutting-edge devices and effective database management techniques can lead to enhanced application efficiency and user experience.

Common Pitfalls and Best Practices

Navigating the complexities of sharding and globally distributed applications requires careful planning and a good understanding of potential issues.

Choosing the Right Shard Key

This is arguably the most critical decision. A poorly chosen shard key can lead to:

• Hot Spots: If many queries or writes target the same shard key (e.g., a popular product ID, or a single tenant in an entity-sharded system), that shard becomes overloaded.
• Inefficient Queries: Queries that don’t include the shard key will often require fanning out to all shards, leading to expensive “scatter-gather” operations.
• Difficult Rebalancing: If the shard key leads to uneven data distribution, rebalancing becomes a constant struggle.

Best Practices:

• Consider Query Patterns: Choose a shard key that aligns with your most frequent query patterns, especially those for write operations.
• High Cardinality: The shard key should have a high number of unique values to ensure good data distribution.
• Even Distribution: Aim for a shard key that naturally distributes data and load evenly across shards. Hashing common IDs can help.
• Immutability: Ideally, the shard key should not change, as updating it would require moving data between shards.
• Compound Keys: Sometimes a combination of columns forms the best shard key.
• Avoid Global Joins: If possible, structure your data to minimize queries that require joining across multiple shards. Denormalization can sometimes help here.

Managing Schema Changes

Schema evolution in a sharded environment can be more complex than in a single database. Applying changes across many shards reliably and consistently requires careful orchestration.

Best Practices:

• Rolling Deployments: Apply schema changes in a rolling fashion, one shard at a time, to minimize downtime and allow for rollbacks if issues arise.
• Backward Compatibility: Design schema changes to be backward compatible initially, allowing older versions of your application to still work during the deployment.
• Feature Flags: Use feature flags to gradually roll out new schema-dependent features, decoupling schema deployment from application feature activation.
• Automated Tooling: Utilize tools or scripts to automate schema migration across all shards.

Operational Overhead

While sharding solves scalability problems, it introduces significant operational complexity.

Best Practices:

• Automation: Automate as many operational tasks as possible, including provisioning, monitoring, backups, and failover. Infrastructure as Code (IaC) is crucial.
• Specialized Teams: Consider having dedicated database reliability engineers (DBREs) or SREs with expertise in distributed databases.
• Comprehensive Monitoring: As discussed earlier, robust monitoring and alerting across all shards and regions are essential.
• Drill for Disaster: Regularly test your disaster recovery procedures. Don’t wait for a real disaster to find out your backups are flawed or your failover process doesn’t work.

Network Latency and Cross-Region Communication

Global distribution inherently means dealing with network latency between regions, which can significantly impact performance.

Best Practices:

• Data Locality: Place data as close as possible to the users who access it most frequently (geo-sharding).
• Minimize Cross-Region Transactions: Design your application to avoid transactions or operations that span multiple geographical regions if possible. If unavoidable, use eventual consistency and asynchronous patterns.
• Caching: Implement aggressive caching strategies at various layers (CDN, application cache, distributed cache) to reduce the number of database calls and cross-region trips.
• Asynchronous Operations: Use message queues and asynchronous processing for non-critical operations to avoid blocking user requests due to network delays.

Sharding and partitioning are powerful techniques for scaling global applications, but they introduce a new set of challenges. By carefully considering your data consistency needs, replication strategies, shard key selection, and operational practices, you can build resilient and performant systems that serve users worldwide.

FAQs

What is database sharding?

Database sharding is a technique used to horizontally partition a database into smaller, more manageable parts called shards. Each shard contains a subset of the data, allowing for improved performance and scalability in globally distributed applications.

What are the benefits of database sharding for globally distributed applications?

Database sharding helps improve performance by distributing the workload across multiple database servers, reduces latency by placing data closer to end-users, and enhances scalability by allowing for the addition of more shards as the application grows.

What are some common sharding strategies used in database partitioning?

Common sharding strategies include range-based sharding, hash-based sharding, and key-based sharding. Range-based sharding involves partitioning data based on a specific range of values, hash-based sharding uses a hashing algorithm to distribute data evenly, and key-based sharding partitions data based on a specific key or attribute.

How does database sharding impact data consistency in globally distributed applications?

Database sharding can introduce challenges related to data consistency, as updates or transactions involving data across multiple shards may require coordination to maintain consistency. Techniques such as distributed transactions or eventual consistency can be used to address these challenges.

What are some best practices for implementing database sharding in globally distributed applications?

Best practices for implementing database sharding include carefully planning the sharding strategy based on application requirements, monitoring and managing shard distribution to ensure balanced workloads, implementing failover and replication mechanisms for high availability, and regularly testing and optimizing the sharding setup for performance and scalability.