Table of contents
Baseline server tuningMySQL performance tuningPostgreSQL performance tuningMongoDB performance tuningMonitoring and benchmarkingScale vs optimizeNext stepsAdditional resources
Get the industry’s best dedicated server hosting◦ 99.999% uptime
◦ Security rich
◦ Built to spec
Explore options

Dedicated Server → Optimize for Database Performance

Optimizing database performance on a dedicated server (MySQL, PostgreSQL, MongoDB, etc.)

Running your database on a dedicated server gives you full control over performance—no noisy neighbors, no shared resource limitations. But to really squeeze the most out of your setup, you’ll need more than just decent hardware.

Let’s walk through server-level optimizations, then dive into performance tuning for MySQL, PostgreSQL, and MongoDB.

Explore dedicated servers
Build now

Baseline performance tuning for any dedicated server

Whether you’re running MySQL, PostgreSQL, or MongoDB, your database is only as fast as the server it’s running on. Start by optimizing the core system resources—CPU, memory, disk, and network—before diving into database-specific tuning.

CPU, memory, and disk I/O: the big three

  • Go for CPUs with strong single-thread performance—many queries aren’t massively parallel.
  • Install enough RAM to hold the entire working set in memory, ideally with ECC for stability.
  • Choose NVMe SSDs for high IOPS and low latency. HDDs will bottleneck modern DBs.

Network tuning

Optimizing how your server handles database traffic over the network can reduce latency and improve response times for remote queries.

  • If your database serves remote applications, enable TCP Fast Open and optimize buffer sizes.
  • Use compression for data over the wire, especially if latency is a concern.

OS-level tweaks

Fine-tuning kernel parameters and filesystem settings helps your operating system manage memory and I/O more efficiently under database load.

  • Tune kernel parameters: vm.swappiness=1, increase dirty_ratio to delay flushes, and boost inode cache.
  • Mount DB partitions with noatime to reduce unnecessary writes.
  • Consider enabling hugepages if your DB engine supports it for large memory allocations.

MySQL performance tuning tips

MySQL performance hinges on how well it’s configured to use system resources and how your schema matches query patterns. These tuning tips help MySQL run leaner and faster on a dedicated box.

Key config changes in my.cnf

These are the most impactful server variables you can adjust to improve memory use, reduce temp table creation, and better manage connections.

  • innodb_buffer_pool_size: set this to 70–80% of total RAM if MySQL is the only major service.
  • Avoid the deprecated query cache (removed in 8.0), but consider temp table memory sizes and join buffer sizes.
  • Set reasonable max_connections to prevent memory exhaustion.

Indexing and schema design

Well-designed indexes and thoughtful schema planning reduce query time and I/O load dramatically.

  • Use EXPLAIN to analyze and rewrite slow queries.
  • Normalize your schema, but denormalize selectively for performance.
  • Add covering indexes and composite keys where query patterns benefit.

MySQL-specific monitoring tools

These tools help identify performance bottlenecks and provide insight into inefficient queries or misconfigured settings.

  • Use mysqltuner for config recommendations.
  • Run pt-query-digest (from Percona Toolkit) on your slow query log.
  • Enable the slow query log and set a low threshold during performance tuning.

PostgreSQL performance tuning tips

PostgreSQL gives you fine-grained control over memory use, parallelism, and disk behavior. Tuning these settings on a dedicated server can drastically reduce query latency and system load.

postgresql.conf essentials

PostgreSQL’s main config file includes settings that directly impact caching, memory use per query, and write behavior.

  • Set shared_buffers to 25–40% of system RAM.
  • work_mem should scale with your expected concurrency.
  • Set effective_cache_size to roughly the size of your system’s file cache.
  • Tune WAL settings and checkpoint_completion_target to avoid write spikes.

Query and schema optimization

Small schema changes and better query structures can yield big performance gains in PostgreSQL.

  • Use EXPLAIN (ANALYZE, BUFFERS) to debug slow queries.
  • Create partial indexes for queries with WHERE clauses.
  • Avoid CTEs as optimization fences in versions prior to 12.

Extensions and tools

PostgreSQL has a rich ecosystem of performance tools and extensions that surface query-level metrics.

  • Enable pg_stat_statements to get query-level stats.
  • Use auto_explain to catch slow nested queries.
  • Run pgBadger for visual reports on query and connection behavior.

MongoDB performance tuning tips

MongoDB is flexible and fast—if it’s configured with your access patterns and data size in mind. On a dedicated server, that means sizing memory correctly and minimizing unnecessary I/O.

Server configuration and scaling

These settings help MongoDB scale while staying performant under high concurrency and growing data sets.

  • Use the WiredTiger engine with snappy or zstd compression depending on CPU tradeoffs.
  • Ensure your RAM can hold the working set plus index data.
  • Use replica sets for read scaling or sharding for horizontal write scaling.

Schema and query optimization

Document structure and query patterns go hand-in-hand. Design for how your app actually accesses the data.

  • Design documents to match access patterns—embedding over referencing where appropriate.
  • Avoid $regex scans and non-indexed $in operations.
  • Use compound indexes aligned with sort and filter operations.

Mongo-specific best practices

Tuning I/O behavior and journaling can significantly affect performance, especially under write-heavy workloads.

  • Use wiredTigerDirectoryForIndexes to separate index I/O.
  • Tune write concern and journaling for your durability/performance tradeoff.
  • Monitor with mongotop, mongostat, and the Ops Manager or Atlas dashboards.

Monitoring and benchmarking

Once you’ve tuned the server and database, the next step is watching how it behaves over time. Good monitoring and stress testing expose the bottlenecks you missed.

Monitoring tools

These platforms help you track resource usage, query performance, and availability in real-time.

  • Pair Prometheus with Grafana for metrics dashboards.
  • Lightweight alternatives: Netdata, Zabbix, or native integrations with Datadog/New Relic.

Load testing

Simulating realistic traffic helps you understand how your database performs under pressure.

  • For MySQL: sysbench and mysqlslap
  • For PostgreSQL: pgbench
  • For MongoDB: mongoperf or custom insert/find benchmarks

Simulate real-world query mixes and concurrency levels to uncover bottlenecks before they happen in production.

When to scale vs when to optimize

There’s a point where performance tuning isn’t enough. Here’s how to know when you’ve reached the limit of what your current server setup can do.

Vertical vs horizontal scaling

Different workloads call for different scaling strategies. Watch system metrics to determine your next move.

  • If CPU, RAM, or disk IO are maxed despite tuning, it’s time to scale up.
  • For read-heavy workloads, add read replicas.
  • For write scaling, consider sharding (MongoDB) or partitioning (PostgreSQL).

Balancing performance and high availability

Performance tuning doesn’t exist in a vacuum. You still need to plan for failover, replication, and backup windows.

  • Performance tuning doesn’t negate the need for replication and backups.
  • Factor in how failover or replication lag might impact perceived performance.

Additional resources

What is a dedicated server? →

Benefits, use cases, and how to get started

How to backup a MySQL database →

MySQL offers various backup methods. Here’s a guide to all of them.

Install and connect to PostgreSQL on Ubuntu →

A complete How To guide

Jeff Goudie is a Training Specialist at Liquid Web. He studied mechanical engineering and computer science, and became an expert at Linux while supporting the engine dynamometers at Chrysler. Jeff joined Liquid Web to help empower customers by educating them about their tech. When he’s not helping Liquid Web teams get better, Jeff enjoys working on his Dodge Magnum.

Let us help you find the right hosting solution

Loading form…