1 When Websites Are No Longer Just Pages
In the blink of an eye, it is already 2026. Looking back, this blog of mine has been running stably for over two years since it was first built. It hasn't been a particularly long time, but it has been enough for me to fully experience the process from “getting the website up” to “starting to repeatedly ponder what a website actually is.”
I still clearly remember how I felt when I first started using WordPress: a pure and direct sense of bewilderment. Not because it was complex, but on the contrary, because it wastoo smooth. Install a theme, and the overall style of the site takes shape instantly; add a few menu items in the backend, drag to reorder them, and the structure of the website is “built”; whatever functionality you need, you usually just install a plugin; and as for the so-called web pages, most of the time they are nothing more than adding a new post or page, and the system automatically generates an accessible URL.
All of this seemed reasonable and efficient, but at the time, it made me vaguely feel that something wasn't quite right—because I realized that I didn't seem to be actually “making pages,” yet I already had a complete website. Many operations that I once thought had to be done by hand were automatically taken over by the system in WordPress. What this experience brought was not simple ease, but rather asense of cognitive weightlessness, and for a long time, I couldn't even understand why the text content couldn't be found in the page's source code. To me, editing text content used to mean directly modifying the source code, but WordPress hid these underlying operations, forcing me to adapt to a completely new way of thinking.
Later, I realized that this discomfort did not come from WordPress itself, but from the website cognitive model that had already formed in my mind. If we roll back the clock more than twenty years, my understanding of “websites” was actually very clear and highly consistent with the technical environment of that time—the era when the “Three Musketeers of Web Design” (Fireworks, Dreamweaver, Flash) reigned supreme:

Fireworks was used for page visual drafts, Dreamweaver was responsible for HTML structure and layout, and Flash took on the role of interaction and animation. From design to implementation, pages were “crafted” step by step and finally deployed to the server as files. The website for my graduation project back then was completed exactly according to this workflow.
In that context, “making a website” was essentially “making pages”: the page was the final form, and the website was merely a collection of these pages. As for content, structure, and interaction, they naturally adhered to the page and were rarely thought of in isolation.
That is precisely why, when I first encountered WordPress's completely different way of working, the impact was so powerful—it didn't just feel unfamiliar on a specific technical point, but on an overall cognitive level, it directly bypassed the entire evolutionary process I was familiar with:

Looking back now, my shock at the time was actually perfectly normal. Because I didn't progress step-by-step from “static pages” to “dynamic websites”; instead, I leaped across more than a decade of technical and conceptual accumulation in almost a single step, moving directly from the old perception of “websites equal collections of pages” to a modern Web model centered around “content” organization. And this shift from page-centric to content-centric is precisely the key transition that WordPress represented and profoundly drove.
As my usage time grew, I gradually realized that what WordPress truly changed was not just the way websites were built, but the way people understood “how websites exist on the Web.” From that moment on, pages were no longer the sole center, and content began to become an object that could be managed, reused, and accumulated over the long term. It was precisely on top of this cognitive shift that subsequent issues regarding caching, comments, and decoupled architectures gradually emerged.
Based on such personal experiences and reflections, this article attempts to start from the specific system of WordPress to review the evolution of the Web at a cognitive level. It is not a tutorial, nor is it a tool comparison, but a retrospective: retracing how we stepped by step moved from “making pages” to “managing content,” and in the process, continuously redefined the “website” itself.
2 The Web of the Past: Websites as ”Collections of Pages”
If we return to the early context of the Web, “websites equal collections of pages” was not a narrow understanding, but a consensus that hardly needed explanation. At that stage, the Web itself was a document-oriented system, and its core capability was very simple: requesting a resource on a server via a URL, and then returning the result to the browser for display.
Under such a model, pages naturally became the center of everything. The URL pointed to a file path, and the server's responsibility was also very clear—reading the corresponding file and sending it out. Whether the file carried an article, an image, or a form did not matter; what mattered was that it was a page that could be accessed and displayed. Consequently, websites were naturally understood as collections of these pages.
Taking the static version of my blog “staticblog.tangwudi.com” as an example, the access path for an article ”Awakening of Voice · Basics (Part 2): From Pitch Names to Numbered Musical Notation” is https://staticblog.tangwudi.com/technology/innerlight14026/:

Under the traditional page model, its URI path ”/technology/innerlight14026/” could directly map to the file path on the host machine's local disk:/data/staticblog/index/technology/innerlight14026/index.html:

When the browser requests this URL from the server, the server simply reads the file and returns the content, which the browser then renders. The article content, images, comments, or other elements have already been statically written into this page file itself, and the page itself is the final form that the user sees.
This example intuitively illustrates the typical thinking of the early Web:URLs correspond one-to-one with file paths, pages are the carriers of content, and websites are collections of these pages. In this mode, if you want to update the article content, you must directly modify the corresponding page file; otherwise, what the browser sees will still be the old page. The core assumption of the entire system was—page is content, content is the final form.
This understanding was not only reasonable but also highly efficient at the time—the page was the final result, and almost all of the developer's work revolved around “how to make the page”: page design, page layout, page interaction, and page publishing formed a clear and linear production chain. As long as the pages existed, the website existed; as long as the pages could be accessed, the website was considered to be “running normally.”
It was also against this background that “making a website” and “making pages” were almost synonymous for a long time. Content was not discussed separately; it was merely a block of text or a set of media resources within a page. Updating content was equivalent to modifying a page; adding new content often meant adding a new page file. The relationships, reuse, and evolution of content were not within the core vision of design.
Under this page-centric model, there were also some underlying premises that almost no one questioned at the time: content was not an independently existing object, but a component of the page; comments, interactions, and feedback were also just part of the display in the page rendering results. They were tightly coupled with the page, together constituting a complete output.
These assumptions worked quite well in the early Web. The number of pages was limited, the update frequency was low, and the lifecycle of content was often consistent with the page itself. At this scale, binding everything within the page was not only intuitive but also easy to understand and maintain. Almost no one would ask: “Should content itself be abstracted separately?”
But as the scale of websites expanded, this model began to reveal its boundaries. The same type of content needed to be frequently updated, referenced, and aggregated, and the number and complexity of pages grew rapidly. When the lifecycle of content gradually detached from individual pages, maintenance costs no longer grew linearly, and pages began to change from the “destination” into containers where content was temporarily placed.
It was also at this stage that people began to realize: perhaps the problem was not that the pages were not made well enough, but ratherwhether pages should continue to bear everything. When pages were forced to bear the responsibility of content organization, structural relationships, and long-term evolution, this page-centric cognitive model of the Web gradually reached its tipping point.
The change that followed was not simply making pages more complex, but a more fundamental shift: what would the Web look like if content were liberated from pages?
3 From Pages to Content Entities
If the previous chapter depicted a well-functioning, page-centric old world, then this chapter discusses the moment that world was truly shaken for the first time. This change was not a performance improvement brought about by a specific technology, but a more fundamental cognitive shift: pages were no longer the sole center, and content began to be treated as an independently existing object.
Before the advent of WordPress, people rarely discussed “content” in isolation. Content was always embedded within pages, treated as part of the final output along with layout, styling, and interaction. Content only existed because the page existed; if the page was deleted, the content vanished with it. The page was both the container and the destination.
The first important thing WordPress did was precisely to break this binding relationship. It introduced concepts like “posts” and “pages,” but this was not a simple classification of pages; it was an abstraction at the semantic level (Note: In the context of WordPress, the so-called “Page” does not refer to the final rendered page result, but is merely another content type. Like “posts,” they are both data objects managed by the system. This point will not be elaborated on in detail later; just remember: they both essentially belong to “content”).
From this moment on, content “escaped” from pages for the first time, becoming an entity that could be stored, managed, and evolved independently—the page was no longer the content itself, but merely a way of presenting the content.
This change seemed very natural at the usage level, yet it brought a fundamental difference at the cognitive level: URLs no longer pointed to specific file paths, but instead became access points for content. The actual content was stored in the database in the form of structured data, with each post being nothing more than an independent record:
Taking the post with the URI path /technology/innerlight14026/ mentioned earlier as an example, on my main blog site, it does not exist in any disk directory. Instead, it corresponds to a record in the wp_posts table of the WordPress database in MariaDB, with an ID of 14026:

As a result, the page was no longer an indivisible final outcome, but merely a view output of the content generated by the system under a specific context.
Content transformed from a “result” into an “asset,” beginning to be preserved long-term in the form of structured data, and possessing a lifecycle that could be maintained, evolved, and reused. It is precisely upon this abstraction that Content Management Systems (CMS) truly became viable. Content could be updated without breaking the overall structure, reorganized without rebuilding pages, and aggregated, filtered, and represented at different times and in different scenarios.
The semantic shift of the comment system also stemmed from this: in WordPress, comments were no longer just pieces of text on a page, but existed as data attached to the content, establishing a relationship with the post while remaining relatively independent in storage and logic. This design naturally provided space for interaction, statistics, and extensibility.
However, this content-centric model did not come without a cost. As pages shifted from “fixed results” to “generatable views,” new complexities emerged. Issues like content stability, real-time interaction, and cache validity—which were naturally masked by the page model—began to surface. It was precisely here that the next round of evolution in Web architecture was forced to unfold—and this is exactly the topic to be discussed in the next chapter.
4 When Content Meets Caching
In Chapter 3, we saw the website complete a key cognitive leap: content no longer exists attached to pages, but is instead abstracted into “content entities” that can be independently managed, preserved long-term, and repeatedly used. Once this step is taken, the nature of the website undergoes a fundamental change—it is no longer a one-off delivered work, but a continuously growing content system. It is precisely at this stage that a problem, which was not prominent in the early Web, begins to gradually surface:Performance。
In the era of “websites equal collections of pages,” performance was not a core conflict. The number of pages was limited, the scale of traffic was predictable, and the update frequency was low. Even if every request was generated on the fly by the server, the cost remained controllable. So-called “performance optimization” was often nothing more than switching to a faster server or reducing a few images.
However, once websites evolved into content-centric systems, the situation became very different. The number of articles continues to grow, and access entry points are more dispersed; the same piece of content may be heavily accessed at different times, or repeatedly crawled by search engines. At the same time, most content is highly stable after publication—it is not frequently modified, yet it is frequently accessed.
This change directly exposed a fact: for the vast majority of requests, the server is doing the exact same thing repeatedly. Every single visit requires querying the database again, reorganizing the content again, reapplying the template again, and regenerating the complete page again. Logically there is no issue, but from a system perspective, this is extremely inefficient. Thus,The caching system emerged:

The introduction of caching is, in essence, a new abstraction: it separates “content generation” from “content distribution.” When a page does not change within a short period, there is no reason for the system to regenerate it on every request. By simply caching the final result temporarily and reusing it directly next time, server load can be drastically reduced while access speed is significantly improved.
In modern websites, caching is not limited to simple page storage. Page caching, object caching, reverse proxy caching, and CDN edge caching stack layer upon layer to form the performance infrastructure of the modern Web. They allow websites to maintain availability and responsiveness even under rapid growth in content volume and traffic.
Technically, caching seems like a simple optimization, but it also quietly changes the operational logic of websites: content no longer relies entirely on real-time generation, but instead takes on a “static” form. This presents almost no conflict for most content, as it is inherently highly stable.
However, as website content begins to include dynamic interactive elements—such as comments, likes, login states, or personalized content—pure caching logic can no longer fully adapt. Caching only determines whether the result of the entire request is reusable; it does not distinguish which parts within the content are stable and which parts might change frequently.
Because of this,the cost of content abstraction gradually becomes apparentWebsites can efficiently handle large volumes of stable traffic, but when dynamic interaction is involved, relying solely on caching is no longer sufficient. This is not a plugin issue, nor is it an accidental phenomenon caused by improper configuration; rather, it is a natural tension that content systems face as they enter the stages of scale and longevity.
5 Comments, Real-time Performance, and Structural Tension
In the previous chapter, content-based websites gained significant performance benefits through caching systems—stable content was efficiently distributed, server load dropped significantly, and websites maintained good responsiveness under large-scale traffic. From an engineering perspective, this is almost an impeccable optimization path. However, the story does not end there.
In most content-based websites, articles are not the only content. Comments, likes, replies, reading status, and user information—though occupying a small proportion of the page—naturally share a common characteristic:they require real-time immediacyWhen a user posts a comment, they expect it to be visible immediately; refreshing the page only to see no update is an experience that is often unacceptable.
In the content semantics of WordPress, comments have been treated as part of the article from the very beginning. They exist attached to the article, share the same access entry point, and are typically output together during the same page rendering process. From the perspective of the content model, there is nothing wrong with this design: articles are content, and comments are also content; together, they constitute a complete content entity.
The real conflict arises after the caching system intervenes. Caching does not understand the difference between “articles” and “comments”; in its view, a URL corresponds to only one reusable response. As long as the cache remains valid, the system will directly return the existing content, without caring whether parts within the page have changed.
Thus, a structural tension begins to emerge: the main body of the article is often highly stable, while the comments change continuously; yet in the caching system, they are forced to share the same lifecycle. For the same URL, either the whole is valid or the whole is invalidated; the cache cannot update only the comment area, nor can it express the semantics of “the content remains largely unchanged, but local parts need real-time refreshing.”
When traffic is low and caching strategies are conservative, this conflict is not obvious. But when a website begins to rely on longer cache times to trade for performance, the problem is magnified: pages can be cached for a long time, while comments are forced to appear with a delay, or even require users to refresh repeatedly to see updates.
At this point, people often attribute the problem to unstable plugins, complex cache configurations, or “poorly tuned” strategies. But from a higher level of abstraction, this is not a problem with a specific implementation detail, but rathera natural tension between two system logics: the content system emphasizes structural integrity and long-term maintainability; the caching system emphasizes stability and reuse efficiency. When strong real-time requirements are embedded into a model centered on stable content, conflict is almost inevitable.
More importantly, this tension does not completely disappear with the accumulation of experience. As long as comments are still treated as part of the page as a whole, one must repeatedly trade off between “performance” and “real-time capability”: shortening the cache time degrades performance; extending the cache time compromises the interactive experience.
From this perspective, the comment issue is not an isolated functional puzzle, but a boundary problem that inevitably exposes itself as the content system enters a mature stage. It reminds us that when content is preserved long-term, widely distributed, and highly dependent on caching,not all information is suitable to remain in the same rendering model。
It is also here that website architecture begins to reach a fork in the road, gradually splitting into two paths: one is to introduce more complex caching rules and invalidation strategies without changing the content model, allowing the original system to carry as many dynamic requirements as possible (such as Cloudflare APO); the other is to rethink the boundary between content and interaction, further decoupling the system.
And this is precisely the starting point for the next stage of architectural evolution.
6 Decoupling Frontend and Backend: An Evolution, Not a Rebellion
In the previous chapter, we saw how content systems gradually reveal structural tension when dealing with comments and real-time interactions. This tension does not stem from a mistake in a specific implementation, but is the result of the natural evolution of the content model to a certain stage: when content is preserved long-term, widely distributed, and highly dependent on caching, the cost of continuing to cram all interactions into the same rendering workflow begins to rise rapidly.
Consequently, a change that seems radical but is actually restrained begins to take place in website architecture:the system no longer attempts to solve all problems at the same level, but instead chooses to split responsibilities。
The first thing to be re-examined is not the content itself, but “how content is presented.” In the traditional CMS model, content storage, page generation, and user interaction are tightly bundled into a single request: the server is responsible for managing content, assembling pages, and handling comments and state changes all at once. This model is highly efficient at a small scale, but as complexity increases, it gradually becomes a limiting factor for the system's continued evolution.
The separation of frontend and backendgradually took shape against this backdrop. It is not a negation of WordPress or CMS, but a further abstraction built upon their success—once content has been clearly modeled and reliably stored, the system begins to make a clear distinction between two types of roles: one responsible for the content itself, and the other responsible for the presentation and interaction of the content.
Under this division, the backend system continues to revolve around content: how content is produced, how it is structured, how it is preserved long-term, and how the relationships between different pieces of content maintain order. Meanwhile, the frontend gradually detaches from the role of “template rendering output,” focusing instead on page organization, interaction pacing, and changes in user state. The two are no longer coupled through the single form of “generating pages,” but collaborate through clear interfaces:

And precisely because of this, content begins to be extracted from the “complete page”: it is no longer delivered directly in the form of the final presentation result, but exists as a resource that can be independently retrieved and combined. The page is no longer the sole destination for content; content can be repeatedly used by different frontends, different devices, and different presentation strategies without changing the way it is stored.
This change directly alleviated the previously recurring structural tension. Stable content can continue to be cached with confidence, while parts with real-time requirements, such as comments, likes, and user status, are dynamically loaded through independent requests. They are no longer forced to share the same cache lifecycle, nor do they have to compromise for each other.
From this perspective, the separation of front-end and back-end is not a “start-from-scratch” revolution, but rather more like a natural division of labor after a system matures. When the content system is stable enough, it instead gains the conditions to be split off and exist as a foundational capability.
It is also at this stage that the forms of websites began to diverge: some moved toward a complete Headless architecture, some combined static generation with incremental updates, some shifted rendering forward to edge nodes, and others, while retaining traditional CMS, only decoupled key interactions. The implementation paths vary, but the underlying motivations are highly consistent—Let stable content remain stable, and let the changing parts have room to change.
The separation of front-end and back-end is not the endpoint of the content system, but rather a sign that it has begun to learn to acknowledge its own boundaries. When a system can actively split itself, it often means it has entered a more mature stage.
7 Vindicating a Misunderstood Revolution
Looking back at the previous chapters, we can see a fairly clear evolutionary path: the Web did not suddenly become complex, nor did WordPress “become heavy” overnight. Pages were abstracted into content entities, and content began to be preserved long-term and repeatedly distributed; comments, permissions, caching, and interactions were continuously layered—each step was a result that naturally grew out of the process of solving real problems.
It is precisely because of this that we frequently hear criticisms today of WordPress being “too heavy,” “bloated,” or “not modern enough.” These feelings often stem from real user experiences, but the problem lies not in the criticism itself, but in the premise of the comparison. Many discussions are actually using modern solutions born for “minimalism,” “single responsibility,” and “complete separation of front-end and back-end” to retrospectively judge a system born more than a decade ago with “long-term content management” as its core goal—this chronological mismatch makes the comparison itself unequal.
If we draw an analogy to World of Warcraft's status in the history of MMO games, it might be easier to understand:
For many veteran online gamers, the significance of *World of Warcraft* has never been just about graphics fidelity, skill mechanics, or numerical systems. The reason it became the icon of an era is that it systematically defined MMOs inworld-building, social relationships, and long-term content evolutionas a basic paradigm.
And today, those games based on modern engines, with more sophisticated mechanics and faster pacing, are indeed more “advanced” in many technical metrics, but their existence cannot retrospectively negate the historical status of *World of Warcraft*. On the contrary, it is precisely because that paradigm was fully validated that successors have the room to make subtractions, optimize, and make trade-offs.
The relationship between WordPress and modern Web architecture is, in fact, highly similar to this.
When we say WordPress is “heavy,” we often overlook one point: this weight is not the result of redundant design, but the accumulation of continuously compounding real-world demands. What it carries is not just the functionality itself, but an entire set of Web experiences regarding how content exists, evolves, and is repeatedly used. It is precisely through the continuous spillover of these experiences that modern Web architecture has gradually taken shape: the storage and evolution of content are still handled by CMS-like systems, while the retrieval and presentation of content are handed over to new middle layers, or even moved forward to the edge of CDNs.
From this perspective, this is not an article defending WordPress, but a retrospective on the evolutionary path of the Web. WordPress is not perfect, nor is it suitable for all scenarios, but it did achieve a decisive leap at a critical historical juncture: transforming websites from a mere collection of pages into a truly content-centric, continuously growing system.
Once this is understood, many debates naturally lose their meaning. What remains is not “whether we should use WordPress,” but whether we realize that the Web capabilities we take for granted today actually stem from that revolution which has already occurred and continues to influence us.
Note: Strictly speaking, WordPress is not the world's first CMS; systems like Drupal, PHP-Nuke, and Movable Type existed before it. But its revolutionary nature lies not in technological pioneering, but in the popularization of a concept—for the first time, ordinary users truly realized that a website is not just a collection of pages, but a content system that can be managed long-term and continuously evolved.
I also think it's very well written, and I have reposted it at https://forum.beginner.center/t/topic/2735
Thank you for the recognition, and thank you for reposting it. More than the repost itself, what I care about is that someone is willing to read it through and resonate with it—that is the most valuable part for me. This article itself doesn't really “cater to current” reading habits, and I didn't think much about its reach when writing it; I just wanted to thoroughly organize my understanding of this issue. To have it seen and appreciated by someone is actually quite rare and precious :).
Indeed, barely anyone reads blogs anymore. If you want more people to see it, you should still post a copy on platforms like WeChat Official Accounts.
I usually post two copies: the WeChat Official Account is convenient for people to read, and my own website is convenient for backup.
I usually post two copies: the WeChat Official Account is convenient for people to read, and my own website is convenient for backup.
True, nowadays mainstream traffic is basically on platforms. If we look at it purely from the perspective of “distribution efficiency,” WeChat Official Accounts or even short videos would have more of an advantage. However, when I started writing this content, I didn't really set “how many people to reach” as my primary goal.
On one hand, this type of article is inherently slow-paced and has a bit of a barrier to entry. If I were to constantly simplify my expression just to fit a platform, it would actually weaken what I truly want to say. On the other hand, I still prefer to treat my blog as a relatively independent place for long-term accumulation, and I don't really want to be completely bound by the rules of any single platform.
I actually quite like this current state—not chasing hot topics, not deliberately distributing. Who gets to see it is actually somewhat “accidental”—and meeting people who are willing to read seriously and engage in discussion is a pleasant surprise instead.
On one hand, this type of article is inherently slow-paced and has a bit of a barrier to entry. If I were to constantly simplify my expression just to fit a platform, it would actually weaken what I truly want to say. On the other hand, I still prefer to treat my blog as a relatively independent place for long-term accumulation, and I don't really want to be completely bound by the rules of any single platform.
I actually quite like this current state—not chasing hot topics, not deliberately distributing. Who gets to see it is actually somewhat “accidental”—and meeting people who are willing to read seriously and engage in discussion is a pleasant surprise instead.
Well written
Thank you, I thought no one would read this kind of article anymore....
Yes, there are,