DEV Community: Meghna Meghwani

How to Fix WordPress Stuck in Maintenance Mode

Meghna Meghwani — Tue, 21 Jul 2026 06:04:35 +0000

You just clicked “Update Now” on a plugin. Thirty seconds later, your WordPress stuck in maintenance mode and shows a white screen that says: “Briefly unavailable for scheduled maintenance. Check back in a minute.” That minute passes. Then ten. Then an hour. You refresh. Still the same message.

If you’ve been there, and plenty of WordPress users have, you already know the sinking feeling. You are locked out of your own website, and your visitors are seeing the same thing. You start wondering if you broke the internet, lost months of content, or need to restore from a backup.

Take a breath. You almost certainly didn’t break anything. Getting WordPress unstuck from maintenance mode is usually a simple fix, and you don’t need to be a server admin to do it. This guide walks you through exactly what’s happening, why it happened, and how to get your site back right now. I will also walk you through the best practices to prevent this issue from returning.

By the time you finish reading, you’ll know how to diagnose the issue, fix it yourself, and harden your setup so interruptions don’t leave you stranded again.

TL;DR

What Is WordPress Maintenance Mode, Exactly?

When WordPress runs an update, whether it’s a plugin, a theme, or the core itself, it needs a moment where nothing else touches the site while files are being swapped out. If a visitor tried to load a page mid-update, they could end up with a half-written file or corrupted database entry.

So WordPress puts the site into a brief holding state. It drops a small file called .maintenance in your root directory, and every visitor, including you, sees that “Briefly unavailable” message instead of your actual content. If you’re new to WP-CLI, the official WP-CLI documentation explains its available commands and how to use them for managing WordPress from the command line.

Under normal circumstances, this is invisible. The update finishes, WordPress deletes the .maintenance file, and everything goes back to normal within seconds.

The problem starts when something interrupts the update process before WordPress can clean up. Maybe your browser tab closed mid-upload. Maybe your internet dropped. Maybe your server ran out of memory and killed the process. When that happens, the .maintenance file stays right where it is, and your site stays locked.

I’ve seen this happen on everything from small personal blogs to agency-managed client sites. The good news is that the fix is almost always the same: find that file and remove it.

How to Tell If Your WordPress Site Is Actually Stuck

Not every slow update means your site is stuck. Sometimes WordPress really is just taking a minute to process a large plugin update. Here’s how to know the difference.

The message is the first clue. If your site displays “Briefly unavailable for scheduled maintenance. When the maintenance message stays visible for several minutes instead of disappearing, it’s usually a sign that WordPress is stuck in maintenance mode and requires manual intervention.
You can’t reach the admin dashboard. If you cannot access your WordPress admin dashboard and visiting /wp-admin redirects you back to the maintenance screen, your site is likely stuck in maintenance mode rather than simply taking longer to update.
The message persists after refreshing. Give it a few refreshes over the course of a minute or two. If it never resolves, something has interrupted the process.
You can confirm it by checking your files. You can verify the issue by checking your WordPress root directory for a .maintenance file using your hosting file manager, FTP, or SSH. If the file exists after several minutes of an update, it is likely causing the maintenance mode lock.

A useful side note: if you see the maintenance message but never initiated an update yourself, that’s actually a red flag. Someone may have triggered an update on your site without you knowing, or a plugin auto-updated itself. Either way, the fix is the same.

What Actually Causes WordPress to Get Stuck?

Understanding why this happens helps you fix it faster and avoid it in the future. Here are the most common culprits I’ve encountered in practice.

Interrupted updates are the most common reason WordPress gets stuck in maintenance mode. If an update is stopped due to a closed browser, lost connection, or system sleep, the .maintenance file may remain and keep the site locked.
Server resource limits can also cause maintenance mode issues. On shared hosting, low PHP memory limits or execution timeouts may interrupt plugin updates, especially when updating multiple plugins or handling large update files.
Plugin and theme conflicts can also interrupt updates. Incompatible plugins, outdated themes, or resource conflicts may cause the update process to fail and leave WordPress stuck in maintenance mode.
File permission problems can also prevent WordPress from exiting maintenance mode. If WordPress lacks proper write access to manage the .maintenance file, it may remain even after a successful update.
Running multiple updates at the same time can create conflicts, especially on multi-user sites. These overlapping processes may leave the .maintenance file behind and keep WordPress stuck in maintenance mode.
Manual maintenance mode activation can also be the cause. If a site owner or developer enables maintenance mode through wp-config.php or a plugin and forgets to disable it, the .maintenance file may remain and keep the site inaccessible.

How to Fix WordPress Stuck in Maintenance Mode

Here’s the step-by-step process I use every time. These steps work regardless of which hosting platform you’re on, though the exact interface will differ slightly.

Read Full Article: https://serveravatar.com/fix-wordpress-stuck-in-maintenance-mode

Hostname vs Domain Name: Key Differences Explained

Meghna Meghwani — Mon, 20 Jul 2026 06:58:20 +0000

If you have ever configured a website, managed a VPS, or set up a server, you have probably encountered the terms Hostname vs Domain Name. Although hostname and domain name are often mentioned together, they don’t mean the same thing. Understanding Hostname vs Domain Name is essential for managing websites, configuring servers, and troubleshooting DNS-related issues effectively.

This confusion is common because both are used to identify systems on a network, and in many cases they appear together in web addresses. It’s easy to assume they are interchangeable, but understanding the difference becomes important when you’re configuring DNS records, setting up email, installing SSL certificates, or deploying applications.

For example, if you are hosting a website on your own server, you’ll typically assign a hostname to the machine while pointing a registered domain name to its IP address. Knowing which one serves which purpose helps avoid configuration mistakes and makes troubleshooting much easier.

In this guide, you will learn what hostnames and domain names are, how they differ, how they work together, where each is used, and which one matters in different real-world scenarios.

TL;DR

A hostname identifies a specific device or service on a network.
A domain name identifies an internet namespace that users can access.
A hostname can exist without a public domain.
A domain can contain multiple hostnames.
Websites commonly use both together, such as “blog.example.com”.
Understanding the difference helps with DNS management, server administration, email configuration, and website hosting.

Hostname vs Domain Name: Quick Comparison

If you’re short on time, here’s the simplest way to understand the difference between a hostname and a domain name.

While hostnames and domain names often appear together, they solve different problems. A hostname identifies a specific system or service, whereas a domain name provides a memorable internet address that groups related services under one identity.

What Is a Hostname?

A hostname is the name assigned to a specific device, server, virtual machine, or network resource. Instead of identifying a machine by its numerical IP address, people can use a hostname that’s much easier to recognize and remember.

Think of a hostname as the label attached to an individual computer. For instance, imagine a company with several servers:

Application Server
Database Server
Backup Server
Monitoring Server

Each server needs its own identity, even if they’re all part of the same infrastructure. Instead of referring to them by IP addresses like 192.168.10.25, administrators assign meaningful names such as:

app-server
db-server
backup-node
monitor-01

These names simplify server management, documentation, monitoring, and troubleshooting. Hostnames are commonly used inside private networks and don’t always need to be publicly accessible.

Where Are Hostnames Used?

You will encounter hostnames in many environments, including:

Linux servers
Windows systems
Cloud virtual machines
Docker containers
Kubernetes nodes
NAS devices
Routers and firewalls
Internal enterprise networks

Whenever a new server is created, assigning a descriptive hostname is considered a best practice because it makes infrastructure easier to understand as it grows.

Need to rename a server? Follow our step-by-step guide on How to Change the Hostname on Linux Easily to update your system hostname safely.

Why Hostnames Matter

Although a hostname may seem like a simple label, it plays an important role in daily system administration. A clear naming convention can help administrators:

Identify servers quickly
Reduce deployment mistakes
Simplify monitoring dashboards
Improve log analysis
Organize infrastructure across multiple environments

For example, compare these two server names:

“server01” vs. “production-api-us-east”

The second hostname immediately tells you what the server does and where it’s located. Small improvements like this become increasingly valuable as your infrastructure scales from a handful of servers to dozens, or even hundreds.

How to Check Your System Hostname in Linux

If you’re using Linux, you can quickly view your system’s hostname using the command line. This is useful when managing servers, troubleshooting network issues, or verifying your system configuration.

Display the Current Hostname

hostname

This command prints the hostname currently assigned to your system.

Example output:

web-server

View Detailed Hostname Information
To display additional details, including the static hostname, operating system, kernel version, and hardware information, run:

hostnamectl

Example output:

Static hostname: web-server
Operating System: Ubuntu 24.04 LTS
Kernel: Linux 6.x
Architecture: x86-64

Display the Fully Qualified Domain Name (FQDN)

If your server is configured with DNS, you can display its Fully Qualified Domain Name (FQDN) using:

hostname -f

Example output:

web-server.example.com

Note: The hostname -f command works only when your system’s hostname is properly configured in DNS or the /etc/hosts file.

Read Full Article: https://serveravatar.com/hostname-vs-domain-name

How to Check Running Processes in Linux Using ps, top, htop & atop

Meghna Meghwani — Sun, 19 Jul 2026 07:00:00 +0000

Managing a Linux server involves more than installing applications and keeping the system updated. To check running processes activity effectively, it’s important to understand how Linux manages every service, from a web server and database to scheduled jobs and background scripts. When a website becomes slow, CPU usage suddenly spikes, or memory starts disappearing, the first place to investigate is the list of running processes.

Linux offers several built-in and advanced tools for monitoring what’s happening inside your system. Some provide a quick snapshot of active processes, while others continuously update resource usage in real time or record historical performance data for deeper analysis.

If you’re new to Linux administration, choosing between commands like ps, top, htop, and atop can be confusing because they all display process information in different ways. Knowing when to use each one can save time during troubleshooting and help you identify performance bottlenecks much faster.

In this guide, you’ll learn what each tool does and how to use it effectively with practical examples.

TL;DR

Linux processes are running instances of applications or system services.
The ps command provides a snapshot of currently running processes.
top displays live CPU, memory, and process activity directly in the terminal.
htop offers an interactive, user-friendly interface with easier navigation and process management.
atop records system activity over time, making it useful for diagnosing performance issues that occurred earlier.
Each tool serves a different purpose, and many administrators use them together for a more complete view of system performance.

Why Process Monitoring Matters in Linux

Every application running on your Linux server consumes system resources such as CPU time, memory, storage, or network bandwidth. Unexpected events like a runaway script, an overloaded web application, or a failing service can quickly affect overall system performance.

Regularly monitoring running processes helps you:

Identify applications consuming excessive CPU or memory.
Detect unresponsive or stuck processes.
Troubleshoot slow server performance.
Verify that essential services are running correctly.
Monitor applications after deployments or configuration changes.
Discover unusual resource usage before it impacts users.

Whether you’re managing a personal VPS or multiple production servers, understanding your system’s active processes makes troubleshooting significantly easier.

Tip: Process monitoring isn’t only for fixing problems. It’s equally useful for validating that a server is operating as expected after updates, deployments, or maintenance.

What Is a Linux Process?

A process is simply a program that is currently running on your Linux system. Every time you execute a command, start a service, or launch an application, Linux creates one or more processes to perform the required tasks.

For example:

Starting the Apache or Nginx web server creates server processes.
Connecting to a server over SSH starts a user session process.
Running a backup script creates a temporary process until the job finishes.
Database servers like MySQL or PostgreSQL continuously run multiple background processes to handle queries and maintenance tasks.

Each process is assigned a unique Process ID (PID), which allows the operating system to manage it independently.

Understanding these basics makes it much easier to interpret the output of process monitoring tools later in this guide. All utilities display process information, they solve different problems. Choosing the right one depends on whether you need a quick snapshot, continuous monitoring, easier navigation, or historical performance records.

When Should You Use Each Tool?

There’s no single “best” command for every situation. Instead, each utility fits a specific workflow.

Choosing the appropriate tool not only speeds up troubleshooting but also gives you more relevant information without unnecessary complexity.

Read Full Article: https://serveravatar.com/check-running-processes-linux

Paperclip AI Guide: Best Use Cases for Automating Business Operations

Meghna Meghwani — Sat, 18 Jul 2026 07:14:33 +0000

There is a moment every founder, CTO, or operations lead hits. You have stripped everything down to the essentials. You have automated what you can with scripts, webhooks, and no-code tools. And still, there is a feeling that you are manually stitching together a set of tools that should, by now, work like a team. Paperclip AI is designed to solve exactly this challenge by helping AI agents work together in structured, goal-driven business workflows instead of isolated automations.

That feeling is not wrong. Most automation today solves individual tasks. It does not solve coordination. Sending a Slack message when a form is filled out is useful, but it is not the same as having someone who knows why that form matters, who to hand it off to, and what to do if the next step fails.

Paperclip is built around a different idea. Instead of automating a single process, it lets you automate an entire operation, with structure, accountability, and costs that scale predictably.

This guide is not a feature list. It is a practical look at what that actually means for your business, and which use cases tend to deliver real value first.

TL;DR

The Mental Model That Changes Everything

Most people approach AI agents like smart scripts. Enter your prompt, receive a response, and continue with the next task.

Paperclip works better when you stop thinking that way and start thinking about agents like employees. Not metaphorically, structurally. Each agent has a role, a budget, a reporting line, and access to the full context of why it is doing something, not just what it was asked to do.

That distinction sounds small. It is not. A marketing agent that understands a blog post is part of a broader objective, such as reaching 10,000 quarterly signups, can make more informed decisions than one who only receives a simple instruction like, “Write a 500-word article about Paperclip.” Context drives alignment. And alignment is what separates AI agents that produce noise from those that produce progress.

This is the mental model that makes Paperclip different from Zapier, Make, or any workflow tool you have tried before. Those tools automate a process. Paperclip automates a department.

What Paperclip Actually Is

Paperclip is a Node.js application with a React dashboard. You install it on a server, define your organizational structure, assign AI agents to roles, and let them work.

Under the hood, it gives you:

Org charts: define who reports to whom
Ticketing: every task is a structured ticket with owner, status, and thread
Per-agent budgets: set spending limits so one agent cannot burn through your entire API quota
Immutable audit log: every decision, tool call, and API request is recorded
Multi-company isolation: run completely separate operations from one deployment

It is open source, self-hosted, and does not send your data anywhere. If you care about where your business data lives, that matters.

Deployment Note: You’ll need to install PostgreSQL, configure the required environment variables, and deploy the application manually. To simplify the process, follow our step-by-step guide on deploying Paperclip on a VPS with ServerAvatar.

Paperclip vs Traditional AI Automation

This comparison highlights how Paperclip differs from traditional AI automation platforms by offering structured agent management, governance, auditability, and scalable business operations instead of isolated task automation.

Read Full Article: https://serveravatar.com/paperclip-ai-use-cases

How to Deploy Paperclip on a VPS with ServerAvatar

Meghna Meghwani — Thu, 16 Jul 2026 06:47:45 +0000

If you’re looking to deploy Paperclip for your team, a VPS gives you full control over your AI infrastructure. Paperclip is an open-source platform that lets you create AI agents, define goals, and connect LLM providers like Anthropic Claude and OpenAI, all from a clean dashboard. The catch is that the hosted version stores your data in Paperclip’s cloud. For companies with strict data privacy requirements, or teams that simply want complete ownership of their infrastructure, self-hosting is the better choice. In this guide, you’ll learn how to deploy Paperclip on a VPS quickly and securely using ServerAvatar.

This guide walks you through deploying Paperclip on a VPS running Ubuntu, behind a custom domain, with HTTPS, a proper PostgreSQL database, and authentication required for every user.

ServerAvatar handles the heavy lifting on server provisioning, application deployment, and SSL certificate management, so you can focus on the setup itself rather than wrestling with DNS records and firewall rules.

TL;DR

Paperclip is an open-source AI agent management platform with a web UI
Self-hosting gives you full data ownership and keeps agent data on your own infrastructure
ServerAvatar simplifies VPS provisioning, application deployment, and SSL management
PostgreSQL 17 is required, Paperclip’s Drizzle ORM doesn’t support MySQL or MariaDB
Paperclip listens on 127.0.0.1:3100 only, Apache handles all public traffic through a reverse proxy
A clean install on a fresh Ubuntu VPS takes roughly 15–20 minutes

What is Paperclip?

Paperclip is an open-source platform that gives teams a web-based control panel for AI agents. You can define agents, assign them goals, manage workloads, and connect your own LLM API keys, without having to build your own tooling from scratch.

Explore the hosted version at paperclip.ing, and access the official documentation and GitHub repository to learn more.

Going the self-hosted route changes the picture significantly:

The self-hosted approach makes the most sense when data residency, internal privacy policies, or avoiding another SaaS dependency are driving your decisions. If any of those resonate, keep reading.

Who this guide is for: Teams that need full control over agent management data, companies with compliance requirements, and developers comfortable on the command line. Budget about 15–20 minutes for a clean install on a fresh VPS.

Architecture Overview

Before diving into the steps, it helps to understand how everything connects.


 ┌──────────────────────────────────────────────┐
 │                   Your VPS                   │
 │                                              │
 │                                              │
Internet ─────────────── Apache :443 (SSL) ─────┼──────► Paperclip :3100
(https://paperclip.example.com)   │             │               │
                                  │ Apache :80──┘               │
                                  │                             │
                                  │   PostgreSQL :5432          │
 └──────────────────────────────────────────────┘

Here’s what each piece does:

Apache (443) – Terminates SSL, handles Let’s Encrypt certificates, receives all public traffic
Apache (80) – Catches plain HTTP requests and redirects them to HTTPS
Paperclip (3100) – The agent management UI that is tied exclusively to localhost, and never directly exposed to the internet
PostgreSQL (5432) – Stores all agent data, configurations, and user information, also localhost-only

Traffic always flows: Client >> Apache (SSL) >> Paperclip (localhost) >> PostgreSQL (localhost). Nothing is directly reachable from the internet except Apache on ports 80 and 443.

Why this design matters

Paperclip is intentionally designed to sit behind a reverse proxy. It binds to 127.0.0.1:3100, which means it cannot be reached directly from the internet under any misconfiguration. Apache handles all SSL complexity. PostgreSQL is on localhost too, so you don’t need to open firewall rules for the database. “systemd” takes care of restarts if the process crashes or the server reboots.

This layered approach means you get a production-ready setup where each component only communicates with the ones it actually needs to.

Step 1: Create Your Server with ServerAvatar

Log into your ServerAvatar account and create a new server. If you already have a server, ServerAvatar makes the process straightforward, you can connect your server from any cloud provider with ServerAvatar using the Direct Method installation guide.

You can also connect your cloud provider account from DigitalOcean, Vultr, Linode, Hetzner, and Amazon Lightsail to directly deploy a server using ServerAvatar.

During the server creation workflow, you’ll see an option to Install Node.js, enable this toggle. Paperclip runs on Node.js, and having ServerAvatar install it during provisioning saves you a manual step afterward.

Step 2: Create the Application in ServerAvatar

After your server is live, create a new application in ServerAvatar.

Open the server panel by clicking on the server dashboard icon.
Navigate to the Application section from the left sidebar.
Click on the Create an Application button.

Enter your application name.
Select your domain from Primary and Test. ServerAvatar lets you deploy applications on a temporary test domain first, useful for verifying your setup before pointing production traffic at it.
Enter your domain name.
Choose Custom PHP Application as the deployment method.

Click on Show Advance Options. Enter New User and give Username and Password.
Select your PHP Version as 8.2
Click on Create Application.

ServerAvatar will create the application structure and set a document root. You’ll deploy Paperclip into this environment. Refer to the custom PHP deployment guide for further details.

Read Full Article: https://serveravatar.com/deploy-paperclip-on-vps

How to Reduce HTTP Requests in WordPress to Improve Site Speed

Meghna Meghwani — Wed, 15 Jul 2026 06:24:04 +0000

Every time someone visits your WordPress site, their browser has to do many things. To reduce HTTP requests, it first has a list of files it needs before it can show a single pixel. CSS files. JavaScript files. Images. Fonts. Tracking pixels. Font icons. Video embeds.

Each item on that list is one HTTP request. And here’s the thing most people don’t realize until they actually look: that list is usually way longer than it needs to be.

I remember opening GTmetrix for a client’s WordPress site for the first time a couple of months ago and seeing 94 requests for a simple blog page. The site was loading four separate JavaScript files from a plugin the client had forgotten they even installed. Just disabling that one plugin brought it down to 71 requests and dropped the load time by nearly two seconds. That’s the kind of gap we’re talking about here.

In this guide, I’m going to walk you through how HTTP requests actually work in WordPress, how to measure them properly, and, more importantly, which optimizations actually move the needle.

TL;DR

Every file your browser fetches is a separate HTTP request, more requests mean a slower site
The biggest culprits are heavy plugins, unoptimized fonts, external tracking scripts, and oversized images
You can cut requests dramatically by auditing what loads, hosting assets locally, deferring non-critical scripts, and using modern formats

What Actually Are HTTP Requests

Think of your browser like a customer in a restaurant where every ingredient needed for a dish comes from a different supplier. Each supplier call represents an HTTP request. The browser makes these requests over a network (not a phone line, but the idea is similar), and every single request introduces a small delay or latency before the page can fully load.

How This Works in WordPress" width="652" height="407">

How This Works in WordPress

Every WordPress page is built using multiple assets that the browser must load before displaying the page.
These assets include CSS stylesheets, JavaScript files, fonts, images, and other supporting resources.
The browser sends a separate request to the server for each asset.
It waits for the server to respond before downloading the requested file.
Once the file is received, the browser continues requesting the remaining assets.
This sequence is repeated until every required resource has been downloaded and processed.
The more assets a page contains, the more requests the browser needs to make before the page is fully rendered.

Every resource that your browser downloads requires its own HTTP request. Understanding which assets generate requests helps you identify where optimization efforts will have the biggest impact.

The table below highlights the most common asset types found on WordPress websites and the best ways to optimize them.

Why This Becomes a Problem

Every file request takes time, even on a fast internet connection.
Requests to a local server are typically faster, while external resources introduce additional delay.
Third-party services, such as analytics, advertising scripts, or embedded widgets, often take the longest to respond.
A typical WordPress page can generate 80 to 100 or more individual requests.
As these requests add up, the browser spends more time waiting for resources to load.
The extra waiting time delays page rendering and interactivity.
This results in slower page load speeds, a poorer user experience, and can negatively affect website performance.

Impact on Performance & SEO

Slow page loading affects more than just the visitor experience.
Search engines consider page speed as one of the signals when evaluating website quality and rankings.
Excessive network requests can slow down the delivery of important page content.
Google Core Web Vitals are directly impacts important performance metrics, including Largest Contentful Paint (LCP).
Delayed loading of scripts and resources can also affect Interaction to Next Paint (INP) by making the page less responsive.
The more requests a page makes, the longer it takes to load and become interactive.
Reducing unnecessary requests can improve performance scores, user satisfaction, and overall SEO.

I’ll skip the surface-level advice and focus on the changes that genuinely speed up a live site. If you want a broader view, I’ve written a complete guide to speeding up WordPress with optimization methods that covers everything from caching to image optimization.

Why Reducing Requests Matters More Than You Think

I’ve seen developers spend days optimizing database queries when the real bottleneck was twenty JavaScript files loading synchronously on every single page. The database was fine. The theme was fine. The plugins were the problem.

When you cut down HTTP requests, three things happen:

First, the browser has less work to do. It downloads fewer files, parses less code, and renders the page faster. For your visitors, this means a noticeably snappier experience, especially on mobile, where network conditions are less predictable.

Second, your server handles less work. Each request consumes CPU and memory on the server side. Fewer requests means your server can serve more visitors simultaneously without breaking a sweat. For growing sites, this is the difference between a server that scales and one that falls over during a traffic spike. If your server response time is already slow, start with my TTFB optimization guide first.

Third, your Core Web Vitals improve. Google measures how quickly your page becomes interactive. Fewer requests means faster LCP, lower INP, and better CLS scores. That directly translates to better rankings.

The good news: you don’t need to overhaul your entire site. A handful of targeted fixes usually handles the bulk of the problem.

Read Full Article: https://serveravatar.com/improve-wordpress-site-speed

How to Add Expires Headers in WordPress

Meghna Meghwani — Tue, 14 Jul 2026 06:36:05 +0000

If you want to add expires headers in WordPress, it’s important to understand how browsers handle your website’s static files. Every time a visitor lands on your WordPress site, their browser downloads images, stylesheets, fonts, scripts, and other assets. If your server doesn’t instruct the browser to store these files locally for a certain period, it has to download them all over again on the next visit. This increases page load times, consumes more bandwidth, and negatively impacts your site’s performance.

The “Add Expires Headers” warning shows up in tools like Google PageSpeed Insights and GTmetrix precisely because it has a measurable impact on page speed. Beyond the audit score, slow-loading assets eat bandwidth, hurt your SEO, and create a poor experience, especially for returning visitors.

This guide walks you through exactly how to fix it. You’ll learn what Expires Headers actually do, how they differ from Cache-Control, which file types should be cached for how long, and most importantly, how to set everything up on your server without breaking your site.

TL;DR

Expires Headers tell browsers how long to keep cached files before asking the server again
They directly improve load speed for returning visitors and reduce server bandwidth
CSS, JS, images, and fonts should be cached for extended periods; HTML should not
NGINX uses expires directives inside location blocks; Apache uses mod_expires in .htaccess
Clear your site cache after making changes, and always test before going live

What Are Expires Headers, Exactly?

When a browser requests a file from your server, the server responds with the file along with HTTP headers. These headers are invisible to visitors but carry instructions that browsers follow.

An Expires Header tells the browser: “Keep this file in your local cache until this specific date and time. Don’t bother asking me for it again until then.”

Without it, the browser has no persistent instruction. It may still cache files temporarily based on its internal heuristics, but it will frequently revalidate with your server, adding latency to every page load.

What this looks like in practice: a first-time visitor downloads your entire page design. A returning visitor three days later should theoretically load everything from their local cache. But without Expires Headers, the browser checks with your server anyway, waiting for confirmation that the files haven’t changed. For a text-heavy page with multiple assets, those round-trips add up fast.

Expires vs. Cache-Control: Why You Need to Know Both

These two get confused constantly, and for good reason, they do essentially the same job. But they go about it differently.

Here’s the practical detail that trips people up: if both headers are present, Cache-Control wins. Browsers prioritize the newer standard and ignore the older Expires date when both exist. Mozilla’s MDN documentation on HTTP caching is a solid reference if you want to go deeper on how these headers interact.

Which One Should You Use?

Most servers today default to Cache-Control because it’s cleaner and more precise. But if you’re manually configuring headers, there’s no harm in setting both, you just need to make sure they don’t contradict each other, or the Expires header becomes meaningless noise.

How Long Should Each File Type Be Cached?

Not every asset on your site deserves the same caching treatment. Getting this right is where a lot of people go wrong, either over-caching things that change often, or under-caching things that never change.

Here’s the logic:

Files that rarely change, like images, stylesheets, JavaScript, and fonts, are ideal candidates for long-term caching. You set them once, and browsers hold onto them for months. The performance gain is substantial because these are typically the heaviest files on any page.
Files that change frequently, like your HTML documents, should get short or zero caching. Your HTML is where new content lives. If a visitor’s browser caches your homepage for a year, they’ll never see your latest blog post. It kills content freshness and makes your site feel broken.
Third-party files, like Google Analytics scripts or Facebook Pixels, are outside your control. You can’t set headers on files you don’t host, so don’t worry about those in your configuration.

Read Full Article: https://serveravatar.com/add-expires-headers-wordpress

How to Remove WordPress Default Image Sizes: Step-by-Step Guide

Meghna Meghwani — Mon, 13 Jul 2026 06:16:43 +0000

If you’ve uploaded images to WordPress, you’ve probably noticed your wp-content/uploads folder filling up with multiple copies of the same image. That’s because WordPress Default Image Sizes automatically generate several resized versions of every uploaded image, even if your website never uses them. Over time, these extra files can consume valuable server storage, clutter your media library, and make backups larger than necessary.

Over time, these extra files waste storage, increase upload processing, and add unnecessary server load. While WordPress lets you change image dimensions, it doesn’t provide a built-in option to disable image size generation completely.

In this guide, you’ll learn how to stop WordPress from creating unused image sizes using a plugin or code, and how to clean up the extra images already stored in your media library.

TL;DR

WordPress creates thumbnail, medium, and large versions of every image you upload by default
These extra files consume server storage and increase upload processing time
You can stop this behavior using a plugin or by adding a filter to your theme’s functions.php file
Existing images need a separate cleanup step to remove previously generated sizes
Choose the method that matches your comfort level with code

What WordPress Does Behind Every Image Upload

Uploading an image to the WordPress Media Library does more than simply save the original file. During every upload, WordPress automatically creates multiple resized versions of that image for use across different areas of your website.

By default, WordPress generates:

Thumbnail: 150 × 150 px (cropped square), commonly used for galleries and widgets.
Medium: Maximum 300 px on the longest side.
Large: Maximum 1024 px on the longest side.
Full Size: The original uploaded image (unchanged).

Custom Image Sizes

The default sizes are only part of the story. Many themes and plugins register their own image dimensions, including:

Page builders
Gallery plugins
Slider plugins
WooCommerce
Custom WordPress themes

As a result, uploading one image can generate 5–10+ files depending on your site’s configuration.

Why It Becomes a Problem

If your website stores hundreds or thousands of images, these additional copies consume a significant amount of server resources.

Common drawbacks include:

Increased disk usage
Slower image uploads
Longer backup times
Higher storage costs
Extra CPU usage during image processing
Larger media libraries to maintain

Example

500 original images × 2 MB each = 1 GB
If WordPress creates five additional sizes per image, total storage can easily exceed 5 GB, even when many of those files are never used.

If your theme never displays certain image sizes, generating them simply wastes storage and processing power.

Two Ways to Control WordPress Image Size Generation

You have two solid paths to stop WordPress from generating image sizes you don’t need.

The plugin route is the most approachable, it gives you a settings interface and doesn’t require touching any code.
The code route is more precise and doesn’t add another plugin to your site, but it does mean working with your theme’s functions.php file.

Neither approach is wrong. Pick based on what you’re comfortable with.

Read Full Article: https://serveravatar.com/remove-wordpress-default-image-sizes

How to Fix "ERR_NAME_NOT_RESOLVED" Error

Meghna Meghwani — Sat, 11 Jul 2026 06:35:29 +0000

You open your browser, type a web address, hit Enter, and instead of the website you wanted, you’re staring at a cold error message: ERR_NAME_NOT_RESOLVED. Your first instinct might be to panic, refresh, or blame your internet connection. The truth is, this error is one of the most common issues on the web, and in most cases, it’s solvable in under ten minutes once you know what you’re dealing with.

The tricky part? The error message tells you what went wrong but not why or how to fix it. That’s exactly what this guide is for.

I will walk you through what triggers the error, how to isolate the cause, and precisely how to resolve it depending on where the problem lives; your browser, your machine, your network, or the website itself. Let’s dig in.

TL;DR

Quick Troubleshooting Checklist

Before diving into the detailed fixes below, use this quick reference table to identify the most likely cause of the ERR_NAME_NOT_RESOLVED error and the recommended solution.

Now that you have an overview of the possible fixes, let’s understand what this error actually means and why it happens.

What Does ERR_NAME_NOT_RESOLVED Actually Mean?

When you visit a website, your browser doesn’t store the IP addresses of every site on the internet. Instead, it asks a DNS resolver, essentially the internet’s phonebook, to translate a human-readable domain like example.com into a numeric IP address like 192.0.2.1. That process is called a DNS lookup.

ERR_NAME_NOT_RESOLVED is what your browser displays when that lookup failed. The resolver was asked for an address it couldn’t find, couldn’t reach, or didn’t have in its records.

It’s worth noting this is different from DNS_PROBE_FINISHED_NXDOMAIN. The latter specifically means the DNS server was reached and definitively said “this domain doesn’t exist.” ERR_NAME_NOT_RESOLVED is broader, it covers lookup failures for any reason, including network connectivity issues, timeouts, or misconfigured settings on your side.

ERR_NAME_NOT_RESOLVED vs Other Common Browser Errors

Many browser errors look similar but point to different underlying issues. Understanding the difference can help you choose the correct troubleshooting steps more quickly.

Now that you know what ERR_NAME_NOT_RESOLVED means and how it differs from other browser errors, let’s start fixing it step by step.

Read Full Article: https://serveravatar.com/fix-err-name-not-resolved-error

Best reCAPTCHA Alternatives to protect website from Spam

Meghna Meghwani — Fri, 10 Jul 2026 05:54:10 +0000

If you’ve ever abandoned a form mid-submission because a blurry CAPTCHA nearly broke your patience, you’re not alone. Every year, millions of legitimate users churn away from websites thanks to CAPTCHAs, those “prove you’re human” challenges that were supposed to make the web safer but often just make it more frustrating. For developers and website owners, finding reliable reCAPTCHA alternatives has become a practical priority: bot protection without destroying user experience is possible, and you have more options than ever.

Google’s reCAPTCHA is the most widely deployed solution on the internet, and while it’s free and reasonably effective, it’s not always the right fit. Some teams have privacy concerns with Google’s data practices. Others find reCAPTCHA’s UX too intrusive for their audience.

In this blog, we will see alternatives to reCAPTCHA.

Why reCAPTCHA Isn’t Always the Answer

reCAPTCHA does a decent job at stopping bots. The problem is that it’s built by Google, and that comes with baggage.

Google’s tracking infrastructure is woven into reCAPTCHA by design. When you embed a reCAPTCHA widget, you’re loading scripts that can fingerprint users across Google’s ecosystem. For privacy-conscious businesses, especially EU-based companies navigating GDPR, this is a real liability. A CAPTCHA that tracks users defeats the purpose of protecting their data.

Beyond privacy, there’s the experience problem. reCAPTCHA’s image challenges are notoriously difficult on mobile. Audio challenges, meant as an accessibility bridge, are often incomprehensible.

Finally, reCAPTCHA isn’t free for high-traffic sites. Google’s free tier is generous for small projects, but as your traffic scales, you start inching toward paid territory, and at that point, you’re paying for something you might not even love.

Invisible Alternatives: No Puzzles, No Images, No Friction

The cleanest CAPTCHA alternative is the one your users never see. Several services now use background signals, browser behavior, proof-of-work computations, device fingerprints, to separate bots from humans without presenting any challenge at all.

Cloudflare Turnstile: A Free and Privacy-Focused CAPTCHA Solution

Cloudflare Turnstile is one of the most popular alternatives to Google reCAPTCHA. It verifies legitimate users using browser and network signals in the background, allowing most visitors to pass without solving image or text-based challenges. This creates a smoother browsing experience while helping websites block automated bots.

Advantages

Invisible verification: Most users are verified automatically without completing visual CAPTCHA challenges, resulting in a frictionless experience.
Easy integration: Implementation is straightforward with a simple JavaScript snippet and site key configuration, making deployment quick for developers.
Privacy-focused: Unlike traditional CAPTCHA solutions, Turnstile is designed to minimize user tracking and does not rely on advertising-related data collection.
Accessibility support: The platform is built with accessibility in mind and complies with WCAG 2.1 Level AA standards, making it more user-friendly for people with disabilities.
Free for many websites: The free plan supports up to 10 widgets, which is sufficient for most personal websites, blogs, and small to medium-sized applications.
Developer-friendly: Minimal backend configuration and clear documentation simplify implementation and maintenance.

Disadvantages

Enterprise pricing is not transparent: Organizations requiring more than the free widget limit must upgrade to an Enterprise plan, where pricing is available only through Cloudflare’s sales team.
Limited free-tier scalability: Businesses managing multiple websites or large-scale applications may outgrow the free plan and need a paid subscription.
Cloudflare ecosystem dependency: Although Turnstile can be used independently, organizations heavily invested in other security platforms may need to evaluate compatibility with their existing infrastructure.

Best For

Small to medium-sized websites
Privacy-conscious businesses
Organizations targeting GDPR compliance
Developers looking for a simple and quick CAPTCHA implementation
Websites that want to improve user experience by reducing CAPTCHA friction

Read Full Article: https://serveravatar.com/recaptcha-alternatives

How to Identify and Kill MySQL Queries Using Command Line

Meghna Meghwani — Mon, 06 Jul 2026 06:21:04 +0000

There comes a moment, usually at the worst possible time, when your application suddenly crawls. Pages take forever to load, API calls time out, and users start complaining. Knowing how to kill MySQL queries quickly can help restore performance and get your application back on track.

In my experience, the culprit behind most sudden MySQL slowdowns isn’t the server running out of memory or CPU, it’s almost always one or two queries that have gone rogue. A missing index on a frequently queried table. A bulk UPDATE running during peak traffic. A cron job that got stuck in a join it can’t finish.

When that happens, you need to get in, find the problem fast, and fix it, without panicking. The MySQL command-line client gives you everything you need to do exactly that. No third-party tools, no elaborate setup. Just SSH in and you’re already diagnosing.

In this guide, I’m going to walk you through the entire workflow: spotting slow queries, understanding why they’re slow, safely terminating them, and putting safeguards in place so the same problem doesn’t come back an hour later. Sound good? Let’s get into it.

TL;DR

Why Do MySQL Queries Slow Down or Get Stuck?

Before we dive into the command-line tools, it helps to know what you’re actually looking at. Most query performance problems fall into a few predictable categories.

Missing or unused indexes are the number one cause in my experience. When MySQL has to scan every row in a table to find a match, queries that should take milliseconds suddenly take minutes. This is especially common on tables that grow quickly, say, a logging table that wasn’t indexed on the timestamp column.
Large result sets are another frequent offender. A query like “SELECT * FROM orders WHERE status = 'pending'” looks harmless until that table hits a million rows. MySQL will happily try to return all of them, locking rows along the way.
Lock contention happens when two queries try to modify the same row at the same time. InnoDB handles this with row-level locking, but if one transaction holds a lock too long, others queue up behind it. In my testing, I found that a single UPDATE running without an index can lock an entire table for 30 seconds or more under moderate load.
Poorly written SQL, nested subqueries, SELECT * in joins, missing WHERE clauses, can also drag a server down. These don’t always show up in development because test data is small. They reveal themselves in production.

The point is: slow queries aren’t random. They follow patterns. Your job at the command line is to spot those patterns quickly.

Connecting to MySQL via Command Line

The first step is getting into MySQL. You’ll need shell access to your server and a MySQL user with the appropriate privileges. For most admin tasks, the MySQL root user is what I reach for, it has full visibility into every connection on the server.

Open your terminal and connect:

mysql -u root -p

Here’s what each part means:

mysql : the MySQL command-line client
-u root : log in as the MySQL root user (swap in a different user if needed)
-p : prompt for the password interactively (never type the password directly in the command, that’s a security risk)

Once you enter your password and hit Enter, you’ll see the MySQL monitor prompt:

mysql>

As shown below:

You’re in. Everything from here runs at this prompt. To exit at any time, just type exit or press Ctrl+C.

One thing I always double-check before proceeding: am I connected to the right database server?

If you’re managing multiple MySQL instances (say, a primary and a replica), it’s worth confirming which one you’re on with:

SELECT @@hostname;

Small step, but it saves you from killing a query on the wrong server, a mistake I’d rather not make twice.

Viewing Running Processes: SHOW FULL PROCESSLIST

Now that you’re in, the first real diagnostic command is “SHOW FULL PROCESSLIST”. This is your window into everything currently happening inside MySQL.

Run it like this:

SHOW FULL PROCESSLIST;

The “FULL” keyword is important; without it, MySQL truncates long queries in the output. You want to see the complete SQL statement, so you know exactly what you’re looking at. The official MySQL documentation covers all the details if you need a reference.

Read Full Article: https://serveravatar.com/kill-mysql-queries

What Is Laravel Livewire? Complete Beginner’s Guide for 2026

Meghna Meghwani — Fri, 03 Jul 2026 05:59:27 +0000

If you’ve been working with Laravel for a while, you’ve probably hit that familiar wall. You need to add some interactivity, a live search, a dynamic form, or a counter that updates without a page reload. Your options often seem limited: build API endpoints, handle CORS and frontend state management with React or Vue, or stick with plain PHP and accept full page reloads. Laravel Livewire offers a simpler approach by letting you build dynamic, interactive interfaces using Laravel and Blade without the complexity of a separate JavaScript framework.

That’s the gap Laravel Livewire was built to fill. Livewire is a framework for Laravel that lets you build dynamic, reactive interfaces using nothing but PHP. You remain in Laravel ecosystem, write PHP, and Livewire will handle JavaScript behind the scenes. No separate frontend build step. No context switching. No API design for internal use cases.

In this guide, I will guide you with Laravel Livewire, its working, when it makes sense to use it, and what its honest limitations are. By the end, you’ll have a clear picture of whether Livewire is the right tool for your next project.

What Is Laravel Livewire?

Laravel Livewire is an open-source PHP framework that integrates directly with Laravel. It lets you build interactive, reactive frontend components using PHP classes and Blade templates, without writing a single line of JavaScript.

A Livewire component combines a PHP class with a Blade view. When users interact with the page, Livewire sends the request to the server, executes the PHP logic, and updates only the changed HTML, allowing the page to refresh dynamically without a full reload.

You get the reactivity of a JavaScript single-page application, but the logic lives entirely in your Laravel backend. If you know Laravel and Blade, you’re already halfway there.

How Does Laravel Livewire Work?

Here’s the mental model that makes everything click.

A Livewire component is made of two parts:

A PHP class holds the component’s state (properties) and its behaviour (methods)
A Blade template renders the UI and binds to the component’s properties and methods

When a user interacts with a Livewire component, Livewire sends the current state to the server, runs the required PHP logic, and re-renders the updated view. Only the changed HTML is returned and updated on the page, creating a smooth, app-like experience.

Since every interaction involves a server request, Livewire works well for most web applications but may not be ideal for highly real-time or latency-sensitive interfaces.

Core Concepts Every Beginner Should Know

Before you start building, a few concepts will help everything else click faster.

Properties

Properties in a Livewire class are the state of your component. You define them as class properties, and they automatically sync with the template.

class SearchUsers extends Component
{
public string $query = '';
public array $results = [];

public function updatedQuery()
{
$this->results = User::where('name', 'like', "%{$this->query}%")->get();
}
}

In the Blade template, $query is referenced directly, no Vue-style binding syntax, no JavaScript. Just wire:model="query" and Livewire handles the rest.

Actions

Actions are public methods on your component class. You trigger them from the template using wire:click, wire:submit, or wire:change.

public function increment()
{
$this->count++;
}

public function submitForm()
{
$this->validate([
'email' => 'required|email',
]);

// Process the form...
}

From the template: Add.

Lifecycle Hooks

Livewire gives you hooks that run at specific moments in a component’s lifecycle:

mount() – runs once when the component is first created
updated($name, $value) – runs after any property is updated
render() – runs every time the component needs to re-render

These let you hook into the component lifecycle to run logic at exactly the right moment.

Directives

Livewire adds a few Blade directives that power the magic:

wire:model – binds an input to a property, syncing bidirectionally
wire:click – calls a component method on click
wire:submit – handles form submission via Livewire
wire:poll – re-renders the component on a timed interval
wire:init – runs a method once when the component first mounts

These directives work as a bridge between HTML and PHP.

Read Full Article: https://serveravatar.com/laravel-livewire