Home / best / centric / developer / hosting

The Ultimate Guide to Developer-Centric Web Hosting

The Ultimate Guide to Developer-Centric Web Hosting

The Ultimate Guide to Developer-Centric Web Hosting

The Ultimate Guide to Developer-Centric Web Hosting

1. Introduction: Why Developers Need Specialized Hosting

Alright, let's get real for a moment. If you're a developer, whether you're building a sleek new SaaS application, a complex e-commerce platform, or even just a personal portfolio site that needs to showcase your cutting-edge skills, you know the frustration. You’ve probably wrestled with some generic web host at some point, one that promised the moon but delivered a rusty old tricycle. You’ve felt that gnawing dread when your meticulously crafted code breaks because the server environment is stuck in 2008, or when a simple `git push` turns into an arcane ritual of FTP uploads and manual file juggling. Trust me, I've been there, pulling my hair out trying to debug a permission error on a shared server that felt like it was actively fighting against my will to innovate. This isn't just about finding a place to dump your files; it's about finding a partner in your development journey, a platform that understands your language, anticipates your needs, and empowers you to build, deploy, and scale with confidence and, dare I say, joy.

1.1 Beyond Generic Hosting: Defining "Developer-Centric"

So, what exactly do we mean when we talk about "developer-centric" web hosting? It's a term thrown around a lot, but for me, it boils down to a fundamental shift in philosophy. Generic hosting, the kind you often see advertised for small businesses or personal blogs, is designed for simplicity and ease of use for non-technical users. It’s got a pretty cPanel, a one-click WordPress installer, and perhaps a drag-and-drop website builder. And for many, that’s perfectly fine! But for us, the folks who live and breathe code, who spend our days in terminals and IDEs, that kind of hosting is often more of a hindrance than a help. It's like trying to perform delicate surgery with a blunt butter knife – you might get the job done, but it’s going to be messy, painful, and far from optimal.

Developer-centric hosting, on the other hand, is built from the ground up with the developer's workflow in mind. It prioritizes control, flexibility, and a rich ecosystem of tools that integrate seamlessly with modern development practices. Think of it as a finely tuned workshop, stocked with all the specialized tools you need, rather than a generic shed with a hammer and a rusty screwdriver. It understands that you might need specific versions of Node.js, Python, or PHP, or that you might want to spin up a Redis instance, configure custom Nginx rules, or run a Docker container. It's about providing the underlying infrastructure and the necessary interfaces that allow you to manage your applications with the precision and autonomy you demand. It’s not just about hosting a website; it’s about hosting an application and the entire development lifecycle that surrounds it.

This distinction is crucial because it affects everything from your deployment speed to your debugging capabilities, and ultimately, your sanity. A developer-centric host acknowledges that you're not just uploading static HTML files; you're building dynamic, complex systems that require specific environments, robust version control integration, and the ability to automate tasks. It’s the difference between being a tenant in a shared apartment where you can’t change anything, and owning your own customizable workshop where you can build whatever you want, however you want it. This isn't just a convenience; it's an enablement. It's the platform that lets you focus on writing great code, rather than fighting with your infrastructure.

In essence, developer-centric hosting is about providing an environment that is transparent, programmable, and extensible. It's about giving you the keys to the kingdom, or at least a very substantial portion of it, so you can tailor the server environment to your exact specifications. This could mean deep SSH access, the ability to install custom software, or even choice of operating system. It's about recognizing that developers are not just users of a service, but architects and engineers who need the foundational tools to craft their digital masterpieces. Without this specialized approach, you're constantly battling against limitations, and that saps creative energy and slows down progress – something no developer can afford in today's fast-paced world.

1.2 The Developer's Unique Requirements

Let’s face it, our needs as developers are… particular. We're not just looking for disk space and bandwidth. We're looking for an environment that understands the nuances of our craft. One of the biggest pain points with generic hosting is the sheer lack of control. You're often locked into a specific, sometimes outdated, software stack. Need a newer version of PHP or Python? Tough luck. Want to install a specific database like PostgreSQL or MongoDB instead of MySQL? Good luck getting that approved, let alone configured correctly, on a shared server. This lack of agency means you're constantly compromising your application's architecture to fit the hosting provider's limitations, which is a recipe for technical debt and frustration.

Another critical requirement is access to the right tools. Modern development hinges on version control systems like Git, continuous integration/continuous deployment (CI/CD) pipelines, and robust command-line interfaces. Generic hosts rarely offer native Git integration, forcing developers into clunky FTP uploads or manual SSH commands, effectively turning every deployment into a high-stakes manual operation. Imagine building a complex application, pushing a small update, and then having to manually upload dozens of changed files, hoping you don't miss anything or overwrite the wrong version. It’s a terrifying thought, and it’s precisely what developer-centric hosting seeks to eliminate by providing the hooks and integrations necessary for a streamlined, automated workflow.

Pro-Tip: The "Git Push" Litmus Test
If a hosting provider doesn't offer a straightforward, documented way to deploy your code via a `git push`, or at least integrate with popular CI/CD services, it's likely not truly developer-centric. This single feature is a massive time-saver and a strong indicator of a modern, developer-aware platform.

Scalability is another beast entirely. Generic hosting often has rigid upgrade paths that involve downtime and manual migrations. As developers, we build applications with the hope of success, and success often means growth. We need the ability to easily scale resources up when traffic spikes, and ideally, scale them down when demand is low to save costs. This dynamic allocation of resources is almost unheard of in traditional shared or even basic VPS environments without significant manual intervention. The thought of an application going viral and crashing because the hosting couldn't keep up is a recurring nightmare for many of us, and it's a problem that specialized hosting aims to solve with elastic infrastructure and intelligent auto-scaling capabilities.

Finally, the need for robust debugging, logging, and monitoring tools cannot be overstated. When things go wrong (and they always do), developers need granular insight into what’s happening on the server. Generic hosting often provides rudimentary error logs, if any, and rarely offers advanced monitoring dashboards or the ability to attach debuggers. This leaves developers flying blind, forced to guess at the root cause of issues, which dramatically increases troubleshooting time and leads to prolonged outages. A developer-centric environment provides the visibility and the hooks to integrate third-party monitoring solutions, ensuring that when an issue arises, you have the data and the tools to diagnose and resolve it quickly, allowing you to get back to what you do best: building amazing software.

2. Core Pillars of Developer-Centric Hosting

When you boil it down, developer-centric hosting isn't just a collection of features; it's a philosophy built on several core pillars that empower us, the creators, to do our best work. These pillars are what distinguish a truly useful platform from one that merely tolerates your existence. They represent the fundamental expectations that any serious developer should have when choosing where to deploy their precious code. Without these foundational elements, you're constantly fighting upstream, patching holes, and building workarounds, rather than focusing on the actual value your application provides. It's about creating an environment where the infrastructure fades into the background, allowing your code to shine.

2.1 Control and Flexibility

For a developer, control isn't just a nice-to-have; it's absolutely paramount. We're not just consumers of a service; we're engineers who need to fine-tune the engine. The first and most obvious manifestation of this is robust SSH access. This isn't just for SFTP; it's for logging directly into your server, navigating the file system, running commands, installing packages, managing services, and debugging in real-time. I remember a time, early in my career, trying to debug a complex PHP application on a shared host where SSH was either non-existent or severely restricted. It felt like trying to fix a car engine with oven mitts on and a blindfold. Every change required an FTP upload, then a prayer, then a page refresh. The ability to just `tail -f /var/log/nginx/error.log` or restart a service with `sudo systemctl restart nginx` is not just convenient; it's an absolute necessity for efficient development and troubleshooting.

Beyond basic shell access, the concept of root access (or at least robust `sudo` privileges on a VPS) is a game-changer. This allows you to install any software you need, configure system-wide settings, manage users and permissions, and truly customize the server environment to your application's specific requirements. Want to set up a specific caching layer like Varnish or Memcached? Need a particular version of a database that isn't pre-installed? Root access gives you that power. Without it, you're at the mercy of the hosting provider's pre-selected software versions and configurations, which are often generalized and outdated. This freedom to sculpt your server environment is what unlocks true potential and allows for innovative solutions that might not fit a cookie-cutter template.

Custom configurations are another critical aspect of control. This extends to web server configurations (Nginx, Apache), database settings, and even language-specific configurations (like `php.ini` or Python virtual environments). The ability to modify these files directly, often through SSH, ensures that your application runs exactly as intended, optimized for its unique demands. For instance, being able to fine-tune Nginx rewrite rules or set specific PHP memory limits without having to submit a support ticket every single time dramatically accelerates development and deployment cycles. It means you can implement performance optimizations or security hardening measures precisely where and how you need them, rather than being constrained by a lowest-common-denominator setup.

Finally, the choice of operating system is a subtle but powerful form of flexibility. While many developers are comfortable with popular Linux distributions like Ubuntu or CentOS, having the option to pick a specific version, or even a different OS like Debian or Fedora, can be beneficial for specific projects or personal preferences. Some applications might perform better on one kernel version over another, or require specific libraries that are easier to install on a particular distro. While this level of choice is usually found in VPS or dedicated server environments, it underscores the developer-centric philosophy: providing the foundational elements that allow you to build from the ground up, rather than forcing you into a pre-packaged, unmodifiable box. This granular control is ultimately about removing friction and empowering the developer to be the master of their own domain.

2.2 Performance and Scalability

Let's be brutally honest: a slow application is a dead application. In today's hyper-connected world, users have zero patience for sluggish websites or unresponsive APIs. This is why performance and scalability aren't just buzzwords; they are non-negotiable requirements for any serious developer-centric hosting solution. When I talk about performance, I'm not just talking about raw server specs, though those are important. I'm talking about the entire chain, from disk I/O to network latency, and how quickly your application can process requests and deliver responses. Dedicated resources, like guaranteed CPU cores and RAM, are crucial here. On a shared host, your application's performance can tank because a "noisy neighbor" on the same server is hogging resources. With dedicated resources, you know exactly what you're getting, and that stability is priceless.

The need for speed extends beyond just the server hardware. It includes optimized network infrastructure, often utilizing content delivery networks (CDNs) to serve static assets closer to users, and robust database performance. A slow database query can bring even the most powerful server to its knees. Developer-centric hosts understand this and often provide options for high-performance storage (like NVMe SSDs), optimized database configurations, or even managed database services that abstract away some of the performance tuning headaches. The goal is to minimize load times and maximize response times, ensuring a snappy user experience that keeps visitors engaged and happy. I remember frantically optimizing image sizes and caching mechanisms on a project only to find out the real bottleneck was the hosting's ancient spinning hard drives. Never again.

Insider Note: The Perils of Unmanaged Scaling
While auto-scaling sounds like magic, remember that it's not a silver bullet. Incorrectly configured auto-scaling rules can lead to "thrashing" (servers spinning up and down unnecessarily) or unexpected cost spikes. Always test your scaling configurations thoroughly in a staging environment before deploying to production.

Then there's scalability, which is where many projects hit a wall if they haven't planned ahead. It's the ability of your infrastructure to handle increased load gracefully, without breaking a sweat. This comes in two main flavors: vertical and horizontal. Easy upgrades/downgrades (vertical scaling) mean you can quickly add more CPU, RAM, or storage to an existing server instance. This is great for predictable, gradual growth. But the real power often lies in auto-scaling capabilities (horizontal scaling), where new server instances are automatically spun up or down based on demand, distributing the load across multiple servers. Imagine a flash sale for an e-commerce site, or a sudden surge in traffic due to a viral social media post; auto-scaling ensures your application remains available and performant without manual intervention.

The beauty of a truly scalable platform is that it allows developers to build applications without constantly worrying about hitting a ceiling. It means you can focus on writing robust, efficient code, knowing that the underlying infrastructure can expand and contract to meet demand. This elasticity not only ensures high availability and performance but also optimizes costs, as you only pay for the resources you actually use. Developer-centric hosts often integrate with cloud providers or offer their own elastic infrastructure, providing APIs and tools that allow you to define scaling rules, monitor resource usage, and even predict future needs. This proactive approach to resource management is a cornerstone of modern web application deployment, freeing developers from the Sisyphean task of constantly adjusting server capacity.

2.3 Tooling and Ecosystem Support

A carpenter is only as good as their tools, and the same absolutely holds true for developers. We need a rich, integrated environment that supports our entire workflow, not just a place to dump our files. This is where tooling and ecosystem support become a critical pillar of developer-centric hosting. The first thing on most developers' minds is native Git integration. This isn't just about having Git installed on the server; it's about the hosting platform actively supporting Git-based deployments. Imagine pushing code to your GitHub or GitLab repository, and that push automatically triggers a deployment to your staging or production server. This "push-to-deploy" functionality is a godsend, eliminating manual FTP transfers, reducing human error, and dramatically speeding up the deployment process. It keeps your codebase versioned and your deployments consistent.

Beyond simple Git integration, robust support for CI/CD pipeline is a hallmark of a truly developer-friendly host. CI/CD (Continuous Integration/Continuous Deployment) is the practice of automating the build, test, and deployment phases of software development. A good developer-centric host provides webhooks, APIs, or direct integrations with popular CI/CD services (like Jenkins, Travis CI, GitLab CI, GitHub Actions) so that every code commit can automatically trigger tests, build processes, and even deployments. This ensures that only tested, functional code makes it to production, reducing bugs and improving overall code quality. I recall the days of manually running tests locally, then deploying, then finding a bug only in production. Never again if I can help it. CI/CD transforms deployment from a stressful event into a routine, automated process.

Specific language/framework compatibility is another non-negotiable. Developers use a vast array of programming languages and frameworks: Node.js, Python (Django, Flask), Ruby on Rails, PHP (Laravel, Symfony), Go, Java (Spring Boot), and many more. A generic host might offer a single, outdated version of PHP and nothing else. A developer-centric host will offer multiple versions of popular languages, allow you to install custom runtimes, and provide the necessary libraries and dependencies. This flexibility means you don't have to compromise on your technology stack to fit the hosting environment; rather, the environment adapts to your chosen technologies. It ensures that your application can leverage the latest features and security patches of its underlying language and framework.

Finally, robust APIs are the unsung heroes of developer-centric hosting. APIs (Application Programming Interfaces) allow developers to programmatically interact with their hosting environment. This means you can automate tasks like spinning up new servers, managing domains, configuring firewalls, deploying applications, or even integrating with your own internal tools. This level of programmability is what truly elevates a hosting platform from a passive service to an active participant in your development ecosystem. It allows for advanced automation, custom dashboards, and seamless integration into complex enterprise workflows, giving developers unparalleled power and flexibility to manage their infrastructure as code, which is increasingly becoming the standard practice in modern development.

2.4 Development Workflow Integration

The developer's workflow isn't just about writing code; it's about the entire lifecycle from idea to production. A truly developer-centric hosting solution understands this and actively integrates with, and enhances, that workflow. One of the most critical aspects of this is the provision of staging environments. Think of a staging environment as a mirror image of your production site, but completely separate and safe for testing. This is where you deploy new features, test bug fixes, and ensure everything works perfectly before it goes live to your users. It's a sandbox where you can break things without consequence. I've seen too many developers, myself included in my early days, deploy directly to production out of necessity, only to introduce a critical bug that took down the entire site during peak hours. That kind of stress is completely avoidable with a proper staging environment.

The necessity of seamless testing goes hand-in-hand with staging environments. A developer-centric host facilitates the running of automated tests (unit tests, integration tests, end-to-end tests) within the staging environment or as part of a CI/CD pipeline. This means that every time you push a new feature, your tests can run automatically, catching regressions or new bugs before they ever reach your users. Some advanced platforms even offer features like "preview environments" that spin up a temporary, isolated environment for every pull request, allowing team members to review changes in a live context before merging. This dramatically improves code quality and reduces the risk of deploying broken code, fostering a culture of confidence and continuous improvement within the development team.

Bulleted List: Key Aspects of a Streamlined Deployment Process

  • Atomic Deployments: Ensures that your application is updated completely or not at all, preventing half-deployed states that can break your site.

  • Zero-Downtime Deployments: Achieved by deploying new versions alongside old ones and then switching traffic, ensuring users never experience an outage.

  • Rollback Capabilities: The ability to quickly revert to a previous, stable version of your application if a new deployment introduces critical issues.

  • Environment Variables: Securely manage configuration settings (database credentials, API keys) that differ between development, staging, and production.


Finally, streamlined deployment methods are the culmination of a well-integrated workflow. This means moving beyond manual FTP uploads and towards automated, repeatable processes. Whether it's "push-to-deploy" from a Git repository, automated deployments triggered by CI/CD pipelines, or using container orchestration tools, the goal is to make deployment fast, reliable, and painless. Developer-centric hosts often provide built-in deployment scripts, deployment webhooks, or direct integrations with popular deployment tools. This automation doesn't just save time; it reduces human error, ensures consistency across environments, and allows developers to focus on building features rather than wrestling with deployment logistics. It transforms what was once a stressful, manual chore into a simple, automated step in the development process, giving developers more time to innovate and less time to worry about infrastructure.

3. Types of Hosting: A Developer's Perspective

Navigating the labyrinthine world of web hosting can feel like trying to pick the right tool from an overflowing, poorly organized toolbox. Each type of hosting has its own nuances, its own strengths, and its own glaring weaknesses, especially when viewed through the critical lens of a developer. What works perfectly for a simple static site won't cut it for a complex, data-intensive web application. Understanding these distinctions isn't just academic; it's fundamental to making an informed decision that will either empower your development efforts or condemn you to endless frustration. Let's peel back the layers and examine each hosting type from a developer's perspective, focusing on where they shine and where they falter.

3.1 Shared Hosting: The Budget Trap

Ah, shared hosting. It's often the first step for many, lured by the incredibly low prices – sometimes just a few dollars a month! On the surface, it seems like a no-brainer for a starter project or a simple blog. You get a domain, an email address, and a place to put your files. For someone building their very first WordPress site with no custom code, it might even work for a while. But for a developer, shared hosting is almost universally a budget trap. It promises convenience but delivers a cage, severely limiting your control and often compromising performance. It's like buying a cheap apartment in a building where you share walls, electricity, and even the same noisy neighbors who throw parties every night, and you have no say in anything.

The fundamental issue with shared hosting is the clue in its name: "shared." Your website shares server resources (CPU, RAM, disk I/O, network bandwidth) with potentially hundreds, if not thousands, of other websites. This leads to the infamous "noisy neighbor" problem. If another site on your server experiences a traffic spike or runs an inefficient script, your site's performance can plummet, completely out of your control. This unpredictability makes performance optimization a futile exercise and debugging a nightmare, as you can never be sure if an issue is with your code or the overtaxed server. For a developer building a web application that needs consistent performance, this is an unacceptable risk.

Beyond performance, shared hosting severely restricts a developer's required level of control. Root access is non-existent, meaning you can't install custom software, configure server settings, or even choose your operating system. You're typically locked into a pre-configured stack, often with outdated versions of languages like PHP or Node.js. Trying to use a modern framework or a specific library that requires a newer runtime version becomes an exercise in frustration or, more likely, an impossibility. Forget about SSH access beyond basic SFTP, let alone setting up custom cron jobs or managing services. Your development workflow is crippled, forcing you back to archaic methods like manual FTP uploads, which are prone to errors and incredibly inefficient for modern development practices.

Numbered List: Why Shared Hosting Fails Developers

  • Resource Contention: Unpredictable performance due to other websites hogging CPU, RAM, and network resources.

  • Lack of Control: No root access, no custom software installation, limited configuration options for server, web server, or language runtimes.

  • Outdated Software Stacks: Often stuck with older versions of PHP, Python, Node.js, and databases, preventing use of modern features and security updates.

  • Security Risks: Vulnerabilities on one shared site can potentially impact others on the same server, increasing overall risk.

  • Limited Tools: Rarely offers Git integration, CI/CD support, staging environments, or advanced logging/monitoring.

  • Scalability Dead-End: No real upgrade path beyond moving to a completely different hosting type, often involving significant downtime and migration effort.


In essence, shared hosting is designed for simplicity for non-technical users, abstracting away all server management. While this is a boon for some, it's a critical limitation for developers who need that level of control and flexibility. It forces you to compromise your application's architecture and your development workflow to fit the hosting provider's lowest common denominator. For serious development work, where performance, control, and modern tooling are paramount, shared hosting is a false economy. It might save you a few dollars upfront, but it will cost you exponentially more in lost time, frustration, and potential project failures down the line. Avoid it for anything beyond a personal static site or a throwaway project.

3.2 VPS Hosting: The Sweet Spot for Many

If shared hosting is the restrictive apartment building, then VPS hosting (Virtual Private Server) is your own private townhouse. You still share the underlying physical hardware with other VPS instances, but each VPS runs its own isolated operating system, with dedicated resources (CPU, RAM, storage) guaranteed to your instance. This isolation is a game-changer for developers, offering a powerful balance of cost-effectiveness, dedicated resources, and, most importantly, control. For many, many developers, especially those working on small to medium-sized web applications, APIs, or custom projects, VPS hosting truly hits the sweet spot. It's often where developers graduate to after outgrowing the limitations of shared hosting.

The primary appeal of a VPS lies in its dedicated resources. Unlike shared hosting, where your performance is subject to the whims of your neighbors, a VPS guarantees you a certain amount of CPU, RAM, and disk space. This means predictable performance, which is absolutely crucial for any application that needs to be reliable. If your application experiences a traffic surge, it won't suddenly grind to a halt because another user on the same physical server is running a resource-intensive task. This predictable environment makes performance optimization much more effective and debugging far less ambiguous, as you can confidently attribute performance issues to your code or configuration rather than external factors.

Perhaps the biggest draw for developers is the root-level control. With a VPS, you get full administrative access to your server. This means you can install any software you need, configure your web server (Nginx, Apache) exactly how you want it, choose your preferred database (PostgreSQL, MongoDB, MySQL, etc.), and select specific versions of programming languages (Node.js, Python, Ruby, PHP, Go, Java). This freedom to customize the environment to your exact specifications is invaluable. Want to set up a custom caching layer like Redis or Varnish? No problem. Need to compile a specific library from source? You can do it. This level of autonomy allows you to build and deploy applications with the optimal stack, without compromise.

Pro-Tip: Managed vs. Unmanaged VPS
VPS hosting often comes in two flavors: managed and unmanaged. An unmanaged VPS gives you full root access but means you're responsible for all server administration (security updates, backups, patching). A managed VPS handles some or all of this for you, but typically comes at a higher cost and might impose some limitations on root access. For developers who enjoy server administration, unmanaged offers maximum flexibility. For those who want to focus purely on code, a managed VPS can be a good compromise.

While VPS hosting offers significant power, it also introduces a degree of management overhead. With great power comes great responsibility, and having root access means you are now responsible for server security, operating system updates, software patching, and backups. This requires a certain level of system administration knowledge. However, for most developers, this is a welcome trade-off, as it provides invaluable experience and the ability to truly understand the underlying infrastructure. Many developers use configuration management tools like Ansible or Chef to automate these tasks, making the management burden much more manageable. The learning curve is real, but the rewards in terms of control and understanding are immense, making VPS hosting a truly empowering choice for the developer seeking an optimal balance.

3.3 Dedicated Servers: Maximum Power and Control

If a VPS is your private townhouse, then a dedicated server is your sprawling, custom-built mansion. With a dedicated server, you get an entire physical machine all to yourself. Every single resource – CPU, RAM, storage, network interface – is exclusively yours. There are no "noisy neighbors," no virtualization layer overhead (though minimal on modern hypervisors), just raw, unadulterated power and complete, unfettered control. This is the ultimate sandbox for developers who demand the absolute maximum in performance, security, and customization. It's the kind of hosting you graduate to when your application's needs transcend what even a robust VPS can offer, or when specific regulatory compliance mandates physical isolation.

The primary reason to opt for a dedicated server is maximum power and performance. When your application is handling extremely high traffic volumes, performing intensive data processing, running complex simulations, or hosting resource-hungry databases, a dedicated server can provide the raw horsepower needed. You're not sharing any hardware, so every single CPU cycle, every byte of RAM, and every I/O operation on the disk is solely dedicated to your application. This translates to unparalleled speed and responsiveness, which is critical for mission-critical applications where milliseconds matter. Imagine an enterprise-level e-commerce platform during a Black Friday sale or a real-time analytics engine processing massive datasets – these are scenarios where a dedicated server truly shines.

Along with power comes absolute control. With a dedicated server, you have full root access and can install any operating system, any hypervisor, and any software you desire. This means complete freedom to tailor the server environment to your exact, unique specifications. You can implement highly specialized security configurations, fine-tune kernel parameters, set up custom networking, or even run a bare-metal hypervisor to host your own virtual machines. This level of customization is invaluable for developers working on highly specific projects, those with stringent security or compliance requirements, or those who simply enjoy the challenge and flexibility of building their infrastructure from the ground up. It's the ultimate canvas for an infrastructure artist.

Insider Note: The "Bare Metal" Distinction
Sometimes, "dedicated server" is used interchangeably with "bare metal server." While they are