Servers & Hosting
guides.

Servers & Hosting articles

89 guides

• Linux High Load but Low CPU: What to Check ↗

  Investigate high Linux load with low CPU usage by examining runnable tasks, uninterruptible waits, storage and pressure signals.

• systemd Timer vs Cron: Diagnose a Missed Job ↗

  Compare systemd timers and cron for scheduled jobs, then investigate missed execution, environment differences and safe retries.

• Nginx 502 with PHP-FPM: Check the Socket ↗

  Trace an Nginx 502 to the configured PHP-FPM upstream, socket permissions, worker health or application failure before changing limits.

• Plesk Server Disk Full: Find Safe Cleanup Options ↗

  Investigate a full Plesk server by separating filesystem capacity, inodes, logs, backups and deleted-but-open files before deleting data.

• Plesk Remote Backup: Verify a Real Restore ↗

  Check Plesk backup scope, remote storage access and restore dependencies, then rehearse an isolated recovery before relying on the backup.

• Plesk Let's Encrypt Renewal Failed: Check Validation ↗

  Troubleshoot a Plesk certificate renewal by checking domain validation, DNS, HTTP reachability and the correct service binding.

• WordPress Email Not Sending: Trace Delivery ↗

  Diagnose missing WordPress mail by separating application generation, SMTP submission, provider acceptance and recipient delivery.

• WooCommerce Checkout Cache: Keep Sessions Private ↗

  Test cart and checkout caching across browser, plugin, CDN and origin layers so that customers do not see another session's data.

• WordPress Staging: Prevent Real Emails and Payments ↗

  Build a safer WordPress staging environment by isolating production data, outbound mail, payment providers, webhooks and search indexing.

• WordPress 504 Gateway Timeout: Trace the Slow Hop ↗

  Investigate a WordPress 504 by tracing the request through the CDN, reverse proxy, PHP workers and database before increasing timeouts.

• WordPress Admin Slow? Diagnose Before Disabling Plugins ↗

  Isolate slow WordPress dashboard requests by measuring PHP, database and plugin behavior on a safe staging copy.

• WordPress Stuck in Maintenance Mode After an Update ↗

  Investigate an interrupted WordPress update, confirm its state and safely restore availability before retrying the update.

• WordPress REST API Failure: Check the Request Path ↗

  Trace a WordPress REST API error through site URL, authentication, permalinks, firewall rules and origin logs without disabling security globally.

• WordPress Scheduled Posts Missed? Check WP-Cron ↗

  Diagnose missed WordPress scheduled posts by checking WP-Cron events, traffic, loopback requests and any external scheduler.

• WordPress Critical Error: Find the Cause Safely ↗

  Investigate a WordPress critical error using recovery mode, server logs and a staging copy before changing plugins, PHP or production data.

• Server Support SLA: Response vs Resolution Time ↗

  Compare support response, restoration and resolution commitments, and identify the coverage and exclusions that make an SLA meaningful.

• VPS Sizing: CPU, RAM and Storage for a Website ↗

  Estimate a starting VPS size from application, database, traffic and backup requirements, then validate headroom with representative load.

• 24/7 Incident Handover: A Practical Template ↗

  Hand over an active infrastructure incident with a clear timeline, customer impact, current hypotheses, owners and the next safe actions.

• Linux Filesystem Suddenly Read-Only: Preserve Evidence Before Repair ↗

  Diagnose an unexpected read-only Linux filesystem using mount state, kernel errors and storage health. Plan supported offline repair and restore validation.

• Linux NUMA Locality: Correlate Remote Memory with the Actual Workload ↗

  Correlate Linux NUMA memory allocation and thread placement with application latency. Test supported locality changes against representative workloads.

• Hyper-V Dynamic Memory: Plan Startup and Runtime Headroom Separately ↗

  Plan Hyper-V Dynamic Memory with measured guest demand, host reserve and startup requirements. Rehearse restart waves and failure placement.

• Windows Nonpaged Pool Growth: Use PoolMon to Identify the Driver Path ↗

  Use repeated PoolMon samples to investigate Windows kernel-memory growth. Correlate allocation tags, driver versions and a tested pilot correction.

• DM Multipath All Paths Down: Define the Application Queueing Policy ↗

  Diagnose all-paths-down multipath events with LUN identity, path state and effective queueing policy. Rehearse application recovery and fencing.

• NVMe SMART Health: Read Wear, Media Errors, and Thermal Trends Together ↗

  Read NVMe health trends across wear, critical warnings, media errors and temperature. Correlate stable device identity with storage and application evidence.

• ZFS Scrub vs Resilver: Interpret Checksum Errors and Recovery Evidence ↗

  Interpret ZFS scrubs, resilvers and checksum errors using pool topology and valid repair copies. Test independent backup restoration separately.

• NFS Hard vs Soft Mounts: Investigate Hangs Without Trading Away Data Integrity ↗

  Understand NFS hard and soft mount failure semantics. Trace server and network evidence, then verify application recovery and complete file publication.

• Linux CPU Steal Time: Separate Hypervisor Contention from Guest Work ↗

  Investigate Linux VM latency using steal time, run queues, task states and host evidence. Separate hypervisor delay from guest CPU and I/O pressure.

• Postfix Deferred Queue Growing: Group Failures Before Flushing or Deleting Mail ↗

  Investigate Postfix queue growth by destination, age, SMTP response, sender origin, and recovery rate before forcing retries or removing customer mail.

• IIS Application Pool Recycling: Preserve Availability While Finding Why the Worker Restarts ↗

  Investigate IIS recycle triggers, overlapping workers, startup and shutdown behaviour, session state, and background work before changing recycle schedules.

• Linux Disk Full but Files Look Small: Check Inodes, Mounts, and Deleted Open Files ↗

  Diagnose Linux storage exhaustion using the correct mount, inode counts, bounded directory scans, and open deleted files before choosing a safe cleanup action.

• Nginx Large Upload Failures: Separate Body Limits, Request Buffering, and Temporary Disk ↗

  Trace upload failures through body-size limits, request buffering, temporary storage, upstream behaviour, timeouts, and application-level completion checks.

• Atomic File Replacement on Linux: Distinguish Reader Safety From Crash Durability ↗

  Design safe file publication with same-filesystem replacement, file and directory durability, error handling, and crash tests for the actual storage stack.

• PHP-FPM max_children: Size Concurrency From Memory and Useful Throughput ↗

  Size PHP-FPM concurrency with representative worker memory, total server headroom, queue evidence, and application throughput instead of a generic formula.

• SES bounces: reconcile transactional delivery events ↗

  Connect accepted sends to later SES bounce and complaint events, with idempotent processing, recipient-state updates and a reviewed retry policy.

• DMARC reports: separate authentication from alignment ↗

  Read DMARC aggregate reports by sender, signing domain and envelope domain so legitimate authentication passes do not hide alignment failures.

• Windows Pagefiles: Reconcile Commit and Crash-Dump Needs ↗

  Review Windows pagefile sizing through peak committed memory, selected crash-dump requirements and available disk capacity rather than a fixed RAM multiplier.

• DHCP Scope Exhaustion: Reconcile Leases and Usable Capacity ↗

  Investigate Windows DHCP address shortages by checking the correct scope, lease state, exclusions and failover context before deleting leases or expanding ranges.

• Defender Performance: Measure Before Adding Exclusions ↗

  Use Microsoft Defender performance evidence to identify scan-related cost, compare application timing and review narrowly justified exclusions with a clear owner.

• Scheduled Tasks: Verify Context, Paths and Actual Output ↗

  Trace a Windows scheduled task from trigger to action by inspecting history, execution identity, working directory and a durable application completion marker.

• Windows Service Logon: Identify the Failing Account Boundary ↗

  Investigate Windows service logon failures by comparing the configured identity, Service Control Manager evidence and service-logon rights before changing accounts.

• PHP Session Locks: Explain Serial Requests from One User ↗

  Diagnose parallel PHP requests that wait on the same session, then shorten session ownership while preserving correct writes and authentication behavior.

• PHP-FPM Slow Logs: Capture the Waiting Request Stack ↗

  Enable a scoped PHP-FPM slow-log investigation, correlate backtraces with real requests and distinguish a sampled waiting stack from a completed root-cause analysis.

• Apache Virtual Hosts: Explain the Site That Answered ↗

  Find why Apache serves the wrong website by checking address matching, ServerName, ServerAlias, default ordering and an HTTPS test with the intended hostname.

• Nginx Upload Failures: Separate Size Limits from Buffering ↗

  Trace a failed upload across Nginx and application limits, temporary-body storage and multipart overhead before raising a request-size setting.

• Nginx Cache Privacy: Separate Bypass from Storage Decisions ↗

  Check whether authenticated requests can read or populate a shared Nginx cache, then verify anonymous and signed-in response isolation with test accounts.

• Nginx Rate Limits: Validate the Key and Burst Behavior ↗

  Design a useful Nginx request limit by testing client identity, shared keys, burst handling and dry-run evidence against representative legitimate traffic.

• Nginx Real IP: Trust the Proxy Chain Deliberately ↗

  Restore accurate Nginx client addresses by mapping trusted proxy hops, selecting the intended header and testing spoofed headers from an untrusted source.

• XFS to a Smaller Volume: Plan Migration Instead of Shrink ↗

  Plan a supported move from XFS to a smaller destination by checking actual data, metadata preservation, application consistency and cutover recovery.

• Ext4 Reserved Blocks: Explain Application Capacity ↗

  Check how ext4 reserved blocks affect ordinary service writers, then review reserve policy alongside actual growth and filesystem role before adjusting capacity.

• Transparent Huge Pages: Test Allocation Latency Tradeoffs ↗

  Review Transparent Huge Page policy, application guidance and compaction evidence before changing Linux memory settings for a latency-sensitive workload.

• Linux Swap Usage: Distinguish Occupancy from Active Pressure ↗

  Investigate swap with interval-based activity, memory availability and application latency so occupied swap space does not become an unsupported tuning decision.

• Linux PSI: Read Resource Stalls Alongside Service Latency ↗

  Use Pressure Stall Information to distinguish resource contention from simple utilization, then correlate CPU, memory and I/O stalls with an affected workload.

• Linux Iowait: Connect CPU Accounting to Storage Evidence ↗

  Interpret iowait without treating it as disk utilization, then compare device latency, workload timing and task delays to find a useful investigation boundary.

• TCP Accept Queues: Diagnose Listener Backlog Pressure ↗

  Investigate new TCP connections that stall by comparing listener queues, application accept behavior and kernel overflow counters before changing backlog settings.

• Linux Descriptor Limits: Inspect the Running Service ↗

  Find why a service reports too many open files by comparing live descriptor use, process limits and the application lifecycle before raising a systemd limit.

• Ubuntu Release Upgrades: Inventory Third-Party Dependencies ↗

  Prepare an Ubuntu release change by mapping third-party packages, supported upgrade paths, recovery evidence and application checks before starting the upgrader.

• APT Signature Errors: Verify the Repository Key Boundary ↗

  Troubleshoot APT repository signature failures by checking Signed-By, key fingerprints, readability and duplicate source entries without bypassing verification.

• Ubuntu Automatic Updates: Make Reboot Policy Explicit ↗

  Check which Ubuntu updates run automatically, distinguish installation from activation and define a reboot procedure that fits your application availability needs.

• Auditd Backlogs: Detect Lost Evidence Before Tuning ↗

  Interpret Linux audit backlog and lost-record counters, investigate the consumer and storage path, and validate a correction without clearing useful evidence.

• Logrotate and Daemons: Verify the Reopen Contract ↗

  Build a reliable log rotation procedure by checking application reopen support, file ownership and postrotate behavior with a controlled marker test.

• SSH Jump Hosts: Review Agent Forwarding Exposure ↗

  Understand what SSH agent forwarding exposes on an intermediate host and test a ProxyJump workflow with explicit destinations and verified host identities.

• AppArmor Custom Paths: Review the Denied Operation ↗

  Connect an AppArmor denial to the responsible profile, review a custom data path and preserve a narrow local policy through application and package changes.

• Linux Service Access: Check Directory Traversal and ACL Masks ↗

  Investigate a service that cannot read a file even when its file mode looks correct by checking parent directories, group membership and effective ACL entries.

• systemd Socket Activation: Find Who Owns the Listener ↗

  Trace a socket-activated service from its listening unit to the application, and explain port conflicts or surprising activation without killing unrelated processes.

• systemd Environment Files: Explain Missing Service Settings ↗

  Find why a systemd service receives different settings from your shell, then validate environment files, quoting and deployment ownership safely.

• A recovery SOP needs business acceptance, not only a started server ↗

  Build a disaster-recovery SOP around dependency order, RTO/RPO evidence, controlled cutover and business acceptance rather than treating server startup as recovery.

• Postfix relay authentication: match the destination and credential lookup ↗

  Diagnose outbound Postfix relay authentication using the actual next hop, SASL lookup key and TLS policy without exposing passwords or weakening relay restrictions.

• SMB access denied: reconcile share access with filesystem permissions ↗

  Trace SMB access through the client identity, share permissions and filesystem ACLs, then validate an authorized file workflow without broad access grants.

• Windows Group Policy: find the effective setting before editing a GPO ↗

  Use resultant-policy evidence, scope and processing context to explain why a Windows setting differs, then validate a narrow policy correction on a pilot group.

• Linux conntrack pressure: investigate new connections that fail ↗

  Trace new-connection failures through connection-tracking occupancy, drop counters and traffic shape, then validate a capacity correction without flushing live state.

• Linux OOM investigations: connect cgroup events to the failed workload ↗

  Separate host memory pressure, cgroup limits and application allocation failures, then use memory-event evidence to size and verify a targeted recovery.

• chrony troubleshooting: verify synchronization before stepping time ↗

  Investigate Linux clock drift using chrony source selection and tracking evidence, then plan correction around application behavior and verify stable synchronization.

• Linux journal retention: preserve the previous boot before cleanup ↗

  Design systemd journal retention around incident evidence, inspect boot coverage and capacity limits, and verify persistence without treating log deletion as incident recovery.

• Deleted Linux files still use disk: investigate open handles safely ↗

  Explain a df versus du gap using filesystem scope and unlinked open files, identify the owning process and recover space through an application-aware close or restart.

• Linux inode exhaustion: why free gigabytes may not permit a new file ↗

  Separate inode pressure from block capacity, identify high-file-count directories safely and verify that cleanup restores the application without deleting required data.

• systemd restart loops: find the first failure before resetting limits ↗

  Investigate Linux service restart loops through exit status, effective unit configuration and start limits, then verify useful recovery beyond an active process.

• Node.js WebSockets behind Nginx: handshake versus idle timeout ↗

  Trace WebSocket failures through the HTTP upgrade, proxy forwarding and heartbeat path, then test idle connections and controlled reconnects behind Nginx.

• Laravel scheduler locks: one runner is not exactly-once work ↗

  Operate Laravel scheduled tasks across multiple servers by separating overlap locks, runner selection, durable job identity and verified business completion.

• Laravel rate limiting across multiple application servers ↗

  Diagnose inconsistent Laravel request limits using shared cache evidence, tenant-aware keys, safe rejection behavior and repeatable multi-server acceptance tests.

• SMTP Queue Growth: Separate Deferrals from Delivery Failures ↗

  Investigate SMTP queue growth using age, destination and failure evidence. Separate transient deferrals, configuration issues and abusive sending before acting.

• Email Migration Cutover: Test the Workday, Not Only Mail Copy ↗

  Plan an email migration cutover with mailbox scope, client access, mail flow and user acceptance. Validate shared resources and application senders before closure.

• CloudLinux LVE Faults: Find the Account Resource Pressure ↗

  Investigate CloudLinux LVE resource faults by connecting account limits to request patterns. Review application behavior before increasing shared-hosting allowances.

• Plesk PHP Upgrades: Review Each Site Before Switching ↗

  Prepare Plesk PHP upgrades with per-site compatibility checks, extension inventories and a rollback decision. Validate scheduled jobs as well as web requests.

• cPanel Backups: Define an Account Restore Acceptance Test ↗

  Review cPanel backup scope and rehearse account recovery with files, databases and mail requirements. Document which restore operations need hosting-provider assistance.

• Windows Update Pilots: Validate Business Applications First ↗

  Plan Windows update pilots with representative devices, application owners and explicit pause criteria. Verify business workflows before broad deployment.

• Apache and PHP Capacity: Separate the Request Paths ↗

  Review Apache and PHP capacity by separating static delivery, persistent connections and dynamic execution. Measure the bottleneck before changing worker settings.

• Nginx Upstream Timeouts: Find the Waiting Dependency ↗

  Diagnose Nginx upstream timeouts with request timelines and application evidence. Review connection, response and dependency behavior before increasing timeout values.

• SSH Hardening: Plan Access Before Changing Policy ↗

  Review SSH authentication changes with a tested recovery path, separate sessions and service validation. Reduce exposure without locking administrators out.

• Investigate performance from the first response. ↗

  Use measurements to find which layer contributes to a slow initial response.