URL in, website out – what actually happens in between?
For visitors, it's remarkably simple: enter a web address, press Enter, and voilà – there's the website.
What happens behind the scenes in those few milliseconds or seconds, however, is considerably more complicated.
Let's take a typical WordPress website as an example. WordPress is a content management system (CMS) developed primarily in the PHP programming language. It allows content to be managed conveniently without having to write code every time.
But WordPress doesn't work alone. To turn a web address into a fully functioning website, several technical systems need to work together.
And what could POSSIBLY go wrong?!
1. DNS – where on earth is the website?
It all starts with a web address, such as https://www.48design.com.
Computers communicate over the internet using IP addresses. To find the right server, your browser uses the Domain Name System (DNS) – essentially the internet's address book.
DNS records such as A, AAAA and CNAME help determine where the relevant server can be reached. Previously retrieved information can be cached to speed things up.
DNS doesn't actually deliver the website. It simply tells the browser where to find it.
What could POSSIBLY go wrong?!
If a domain expires, a DNS record is misconfigured or the responsible DNS service goes down, the browser may no longer be able to find the server. The website becomes unreachable – even though everything on the server itself is working perfectly.
It happened on 10 February 2026: Authentication provider Clerk experienced a DNS outage. Important API domains couldn't be reliably resolved for more than two and a half hours. The actual application servers were still running, but some users couldn't reach them.
So the website or application is working just fine. Nobody can get to it, though. Congratulations!
2. HTTPS – let's see some ID first!
Once the IP address is known, the browser establishes a connection to the server.
Because our example address starts with https://, communication is encrypted using TLS/SSL. The server presents a digital certificate, which the browser checks.
If everything checks out, the actual HTTP requests can be transmitted over the secure connection.
What could POSSIBLY go wrong?!
Certificates have an expiry date. If they're not renewed in time or are incorrectly configured, visitors may be greeted by a rather alarming security warning. Sometimes all it takes is a hosting provider that doesn't renew certificates automatically and eventually decides to switch off the lights.
Not exactly a great look for a business website. Rather like putting up a sign saying "Enter at your own risk".
Technical standards also change regularly. Outdated encryption methods disappear, security requirements become stricter and certificate authorities adjust their procedures.
An example from August 2025: Let's Encrypt discontinued its previous OCSP service for checking certificate revocation. Existing certificates didn't suddenly become invalid, but the change demonstrates that even the internet's fundamental security mechanisms don't stay the same forever.
3. CDN, proxy and web server – the internet's bouncers
Not every request goes straight to the actual web server.
Services such as Content Delivery Networks (CDNs), reverse proxies and load balancers are often placed in front of it. They distribute requests, cache content, reduce server load and can help fend off attacks.
The actual web server – such as Apache or Nginx – then processes the HTTP request.
It determines which website is responsible, checks access rules, handles redirects, compresses files and delivers content. For dynamic pages, it passes processing on to other software, such as PHP.
What could POSSIBLY go wrong?!
Incorrect access rules lock visitors out, broken redirects go round in circles, and overloaded servers eventually refuse to cooperate.
It's particularly annoying when the very service that's supposed to improve reliability is the one that breaks down.
An example from 18 November 2025: A change to database permissions at infrastructure provider Cloudflare resulted in a faulty configuration file being generated and distributed.
The result was widespread outages and HTTP errors affecting numerous websites and services. Their actual application servers weren't necessarily affected.
A small configuration problem with enormous consequences. Turns out the internet can play dominoes too.
4. PHP – now we're actually programming!
Now we get to the actual processing of our WordPress website.
WordPress is primarily written in PHP. Many themes and plugins also use this server-side programming language.
PHP runs on the server. It loads WordPress, processes configurations, includes extensions, performs calculations, handles forms and communicates with databases.
Visitors normally don't see any of this. They only see the result, not the PHP source code.
What could POSSIBLY go wrong?!
PHP is constantly evolving. New versions introduce security improvements and new features, but they can also change existing behaviour or remove outdated functions.
An older plugin might suddenly start throwing errors. Things get even more serious when security vulnerabilities are discovered in PHP itself.
And that's exactly what happened on 21 October 2026.
The PHP project released security updates for two critical vulnerabilities (CVE-2026-109618 and CVE-2026-109619), each rated 9.2 under CVSS v4.0. On a scale that goes up to 10. So yes, pretty bad. Very, very bad!
Under certain conditions, attackers could exploit these vulnerabilities to execute their own code on affected servers without having to log in.
Even more alarming: In certain configurations, an attack could succeed before the actual WordPress code was even executed.
The PHP project released patched versions. Affected systems had to be updated, potentially followed by compatibility checks. If you run a website, you might even have noticed something happening. If not, there was certainly plenty going on behind the scenes!
And here's the crucial point: A website could have been programmed perfectly well for years and still suddenly become vulnerable to these security flaws.
The problem wasn't in WordPress, the theme or a plugin. It was in PHP itself.
The original programming hadn't suddenly become bad. The technical security situation had changed. And somebody had to deal with it.
5. The database – the website's memory
Alongside PHP, WordPress generally needs a database, such as MySQL or MariaDB.
This is where page content, posts, user accounts, settings and plenty of other information are stored.
When a visitor requests a page, WordPress uses PHP to determine which data is needed and sends the relevant queries to the database. The database returns the information, and PHP processes it.
Images, documents and program files, on the other hand, are normally stored in the file system. The database manages the associated information and relationships.
Easy. What could POSSIBLY go wrong?!
If the database becomes unavailable, practically all dynamic content may disappear. Damaged tables, faulty queries or incompatible updates can bring individual features – or the entire website – to a standstill.
And then there's the small matter of data loss.
A hardware failure, a botched update or an accidentally deleted table – and suddenly the fun is over.
That's why regular backups are so important. Although there's one thing worth remembering: A backup that can't be restored when you actually need it is about as useful as an umbrella full of holes.
Backups need to be properly organised and occasionally tested too.
6. WordPress, themes and plugins – time to make it look pretty!
Once PHP and the database have provided the necessary information, WordPress processes it using the active theme and installed plugins.
The theme determines the structure and appearance. Plugins add features such as contact forms, multilingual support, online shops and other functionality.
The result includes the HTML document that the web server sends back to the browser.
What could POSSIBLY go wrong?!
Plugins can interfere with each other, become incompatible or contain security vulnerabilities. Some eventually stop receiving updates, while others change developers or owners.
And sometimes a single problematic extension is enough to put an entire website at risk.
It happened in August 2024: A critical security vulnerability (CVE-2024-28000) was discovered in the LiteSpeed Cache WordPress plugin. At the time, the plugin was installed on more than five million websites. No big deal, then...
Under certain conditions, attackers could gain administrator privileges without logging in normally. The vulnerability received a CVSS v3.1 score of 9.8. Just a little reminder: 10.0 is the top of the scale!
Not exactly the kind of extension you'd want on your website.
That's one reason why we at 48DESIGN prefer to keep plugins to a minimum. While some WordPress installations resemble full-blown plugin collections, we often aim to get by with around three to five.
Fewer plugins don't automatically mean better security. But every additional extension introduces another dependency that needs maintenance and updates.
Where it makes sense, we'd rather develop the required functionality ourselves.
7. HTML, CSS and JavaScript – finally, the browser takes over!
Up to this point, most of the website's processing has happened on the server. Now the browser receives the generated HTML document and starts rendering it.
HTML describes the structure and content, CSS takes care of the appearance, and JavaScript makes interactive features possible.
The browser loads additional files such as images, fonts, stylesheets and scripts, calculates the layout and finally draws the website on the screen.
Done! The website is here.
What could POSSIBLY go wrong?!
Browsers are constantly evolving too. Outdated JavaScript libraries may contain security vulnerabilities, previously supported features disappear, and new security policies can block external resources.
Suddenly, the navigation menu stops working on a smartphone, a form becomes unresponsive, or the layout looks as though someone has given all its elements a vigorous shake.
And with visitors using all sorts of devices, operating systems and browsers, there's plenty of room for surprises.
A website doesn't just have to remain compatible with its server. It also needs to work with the software its visitors use.
And that's nowhere near everything!
Our little journey from URL to finished website actually covers just a fraction of what happens behind the scenes.
Each of these seven steps could be broken down into far more detail, with additional technologies, dependencies and potential points of failure.
Then there's web hosting, server operating systems, storage, backups and the entire email infrastructure. And, of course, none of these services necessarily has to be hosted by the same provider or maintained by the same company.
A website isn't one single piece of software. It's part of a complex technical ecosystem. And the more moving parts there are, the more things can change – even when nobody touches the website itself.
Built once doesn't mean responsible forever
Professionally developing a website and providing ongoing technical maintenance are two different services.
When you commission an agency to build a website, you're initially paying for the agreed services – such as concept development, web design, programming and publication. Once the project has been successfully completed and accepted, that work is generally considered delivered.
Of course, statutory and contractual warranty rights still apply. An agency remains responsible, within the applicable legal framework, for defects in the work it originally agreed to provide.
It's a different matter, however, when a hosting provider updates PHP years later, a plugin develops a new security vulnerability or an external service suddenly changes how it operates.
Commissioning a website once doesn't automatically entitle you to free maintenance for life.
Wouldn't that be nice, though? Buy a car once and have the manufacturer pay for every future inspection, repair and replacement part. Where do we sign up?
That's exactly what service and maintenance agreements are for
To make sure technical maintenance isn't left to chance, we offer service and maintenance agreements at 48DESIGN.
Depending on the agreed scope, we take care of WordPress, theme and plugin updates, check technical dependencies, carry out maintenance work and respond to security-related developments.
Backups, functionality checks and coordination with hosting providers can also be included. After all, professional maintenance isn't just a matter of clicking "Update" everywhere and keeping your fingers crossed.
Exactly which services are covered depends on the agreement. A maintenance contract is neither a guarantee that nothing will ever go wrong nor a free pass for unlimited development work.
And yes, in theory, we could monitor every single client's website around the clock, track every technical change and react immediately to every conceivable problem.
The effort involved would be enormous, though – and so would the monthly bill. For most businesses, that level of all-inclusive support would simply be disproportionately expensive.
That's why we focus on services that match actual requirements. Individual maintenance tasks and troubleshooting can, of course, also be commissioned without an ongoing agreement.
What matters is having clearly defined responsibilities and fair billing for the work involved.
"But we haven't changed anything!"
So the next time your website suddenly stops working even though you haven't changed a thing, you'll now know something else: There's a very good chance we haven't changed anything either.
Perhaps the hosting provider installed an update. Perhaps a certificate expired, a DNS service went down or a software component decided it was time to stop doing things the way it used to.
Some other little cog in the internet's enormous machinery may simply have given up.
That doesn't make the situation any less frustrating, of course. And as the developers of your website, we're often the right people to investigate the cause and fix the problem.
But troubleshooting takes work too – sometimes a few minutes, sometimes several hours. Unless the problem is a defect we're legally or contractually responsible for, that work is a separately chargeable service.
Just because we know how to fix a problem doesn't automatically mean we caused it.
Our conclusion: A website is never truly finished
As our little journey has shown, numerous technical components work together behind the scenes. Any one of them can change, require an update or suddenly cause problems.
A website therefore isn't a one-off product that will continue working unchanged forever. It needs regular technical maintenance – and clearly defined responsibilities.
We build websites designed to work reliably for as long as possible. And if you'd like us to, we'll help make sure they stay that way.
Would you like professional maintenance for your website or need help with a technical problem? Get in touch. We're happy to help – with expertise, transparency and clearly agreed services.