
Do websites seem to load slowly? Even though gigabit-speed connections are now available in offices and homes alike, each page load still takes a couple of seconds—just as it did back in the days of old ADSL connections. Why haven’t website loading speeds really improved, even though connection speeds have increased rapidly?
The reason is that in traditional web development—the so-called “legacy web”—web pages always require multiple server components. A request from the user’s browser passes through several layers before the final page is displayed to the user. The connection between the user and the webpage is fast enough, but the various server components slow things down, causing the site to load slowly for the user. As user numbers begin to grow, it also becomes more expensive to scale the entire application architecture (monolith), because applications demand more server resources (e.g., web server, application, database, etc.).
Legacy web systems have other problems as well: multi-tiered functionality provides attackers with just as many opportunities to exploit vulnerabilities.
In any case, web pages are often mostly static
Web pages often consist largely of static content. Even on this G-Works site, virtually everything you see is displayed the same way to all visitors every time. So why retrieve data from the application’s database every time, when the content can be pre-generated for the user right from the first load?
By avoiding constant, unnecessary database calls, the end user can access the information more quickly, resulting in a better user experience. Even for the slowest internet connections, the loading order can be configured so that images load only after the text content. The user can start reading the content while the images are still loading.
Dynamic and static elements are not mutually exclusive. When designing web applications, it’s worth considering whether the content is dynamic or static. Dynamic content should be used in sections where it is actually needed. And whenever possible, it’s best to use existing interfaces without integrating with a third-party system.
GW 2.0 is G-Works’ new approach to website development
For the past year, G-Works has been preparing a new development approach, which we refer to by the project name GW 2.0. The website you’re reading right now is an example of how our new solution works in practice. You’re browsing a static website whose content is updated only when changes are made to the content on the WordPress side. Load times are fast, and browsing is smooth.
Security has also been taken into account. Content is primarily built during the so-called compilation phase, and calls to backend systems are minimized. Since calls are made exclusively through strictly defined APIs, the system is less vulnerable, and the potential for an attack can be limited to only a small part of the application.
Websites must, of course, be scalable. In GW2.0, this challenge can be addressed by deploying the user interface (UI) across multiple different environments.
To describe this in slightly more technical terms: the solution can be deployed using Docker, and it also supports several different CDN solutions. Architecturally, it can also be customized for an on-premises environment if necessary. Since the UI layer is separated from the backend systems, the UI can, for example, be geographically distributed very easily. Depending on the overall setup used in the project, the scalability of the backend systems, for example, is either handled by the platform providers (PaaS solutions) or, in an on-premises scenario, by, for example, WordPress (implemented as a headless solution), does not require such massive scalability, since calls to the WordPress API are made during the compilation phase and are optimized.
Industry professionals certainly kept up. In short: GW 2.0 is highly scalable and highly flexible.
Modularity Drives Development Speed
The guiding philosophy behind GW 2.0 is modularity. This term is used slightly differently in various contexts, so it’s certainly worth explaining what it means in our approach.
Let’s use an example:
A main website has already been built for a client, but a separate campaign site will be needed in the future. For this purpose, a separate UI component can be created that is completely different from the main website itself—for example, in terms of style or content.
The client can enter content for the campaign site even before the site is completed, and since the backend system supports integration via an API, the campaign site can also be connected to it. Since the development philosophy has been modular from the outset, it’s possible to add, for example, e-commerce products or other content to the campaign site that isn’t used on the main site. The user interface is simply connected to the backend systems that generate this data.
Since the front-end (UI) and back-end systems communicate with each other via APIs, applications can be developed in smaller increments and leverage the client’s existing systems. Therefore, G-Works does not necessarily always need to implement a new WordPress environment for the client if the client does not need one and the existing installation has been implemented properly.
The technology we use already has community-developed plugins that allow integration with common interfaces (CMS, e-commerce, and other platforms). If necessary, and if support isn’t available through the community, G-Works can implement such solutions as well.

Why should you purchase a website from G-Works?
GW 2.0 isn’t the only approach we take to all our projects. In fact, when defining a project, we don’t even usually talk about GW 2.0 per se, but rather about the solution that best suits each client. However, for the sake of clarity, we’ve decided to describe the concept in this blog using this internal working title.
If an organization is growth-oriented and not all future development needs are yet known, our modular development approach is often a highly appropriate solution.
The benefits can be summarized in five points:
- Performance
- Scalability
- Maintainability
- Security
- Infrastructure portability
Like our other solutions, GW 2.0 does not result in so-called vendor lock-in. If the customer so desires, any other party can retrieve data from the interface provided by G-Works or, alternatively, provide an interface to which G-Works can connect.
GW 2.0 is a highly modern way to develop web services, and if that sounds intimidating, don’t worry. Our experts still speak in plain language. However, I wanted to share this blog post primarily with my professional colleagues.


