Why did PressUp choose NodeJS/NextJS and pure HTML as the backbone for its CMS and web client?
PressUp, when building its Ultra CMS and web client systems, didn't follow the common path of choosing an "all-in-one" framework. Instead, they opted for a seemingly familiar but highly deliberate combination: Node.js for the backend, Next.js for the modern frontend, and in many cases, pure HTML for parts requiring absolute optimization.
In the modern web development world, technology choices are not just technical matters, but strategic decisions that directly impact a business's speed, performance, scalability, and operating costs. Each technology stack embodies a philosophy: some prioritize speed, others stability, and still others focus on encapsulation and ecosystems. However, the deeper we delve into practical operations, the clearer one becomes: **there is no "best" stack, only the "most suitable" stack for the goal.**
This wasn't a random choice, but rather the result of viewing the web not just as an interface, but as an operating system. And within that system, each layer of technology must serve a clear objective.
- Starting with the philosophy: Technology must serve operations, not the other way around.
Many web systems fail not because they lack features, but because they are "constrained" by technology. When a stack is chosen simply because it's popular or because it's "trendy," the system will soon encounter limitations when real-world needs arise.
PressUp approached the problem from the opposite perspective. They started with the question: what does the system need to do? Who does it serve? How does it operate? Only then did they choose the appropriate technology.
This leads to an important principle: **don't choose technology to show off, choose to control**. And to do that, you need a stack that is flexible enough, widely available enough to be easy to develop, but also "open" enough not to be locked down.
NodeJS, NextJS, and pure HTML meet those criteria precisely.
- NodeJS: A flexible, lightweight, and easily scalable backend.
NodeJS isn't a new technology, but its strength lies in its simplicity and scalability. With its non-blocking I/O model, NodeJS allows for handling multiple requests simultaneously without requiring significant resources.
In the context of CMS Ultra, the following needs to be addressed:
- Customer data
- API integration
- Internal operating logic
NodeJS became a logical choice because:
- Easy to build APIs
- Easy to integrate with other systems
- Easily expandable to meet needs
More importantly, NodeJS uses JavaScript – the same language as the frontend. This reduces the gap between system layers, making development and maintenance easier.
This isn't about "writing code faster," but about **reducing the complexity of the entire system**.
- NextJS: When the frontend is more than just a user interface.
Traditional frontends are typically only responsible for display. But with NextJS, the frontend becomes a crucial part of the overall architecture.
NextJS offers:
- Server-side rendering (SSR)
- Static Generation (SSG)
- Incremental static regeneration (ISR)
This allows for optimization:
- SEO
- Page load speed
- User experience
In CMS Ultra, where each website can be customized to each client, NextJS helps create a flexible frontend layer while maintaining high performance.
There's no need to choose between "fast" and "beautiful"; the system can achieve both.
- Pure HTML: Where simplicity is power
While many systems run on cumbersome frameworks, PressUp retains a seemingly "old-fashioned" option: pure HTML.
This isn't outdated, it's a strategy. With the necessary pages:
- Extremely fast download speeds
- Maximum SEO
- Less complex interactions
Pure HTML is an almost perfect choice.
No unnecessary JavaScript, no large bundles, no complex logic. The website returns to its true nature: fast, lightweight, and stable.
This is an important philosophy: **sophisticated technology isn't always needed to solve a problem**.
- Combination: Not choosing one, but using the right one in the right place.
The strength of PressUp lies not in each individual technology, but in how they are combined.
NodeJS handles the backend and logic.
NextJS handles the modern frontend.
Pure HTML is used for parts that require the highest level of optimization.
Instead of applying a single stack to everything, the system is designed according to the following principle:
**Each technology serves a specific purpose**
This helps:
- Performance optimization
- Reduce costs
- Increased control
And most importantly, it avoids "over-engineering".
- Performance: Speed is not an option, it's the standard.
In the online environment, speed is crucial. A slow website not only reduces user experience but also directly impacts revenue and SEO.
With the combination of NodeJS + NextJS + pure HTML, PressUp achieves:
- Fast response time
- Optimized page load
- Ability to handle multiple requests
This is especially important for online retail or education systems, where traffic can surge dramatically.
Performance is no longer something to be "optimized later," but is built right from the ground up.
- Integration capabilities: API-first is the default.
NodeJS simplifies API development. This aligns with CMS Ultra's philosophy: connecting to multiple different systems.
From CRM and ERP to third-party services, the system can:
- Send data
- Receive data
- Real-time synchronization
This is the foundation for building an open ecosystem where websites are not isolated.
- Customization: When each customer is a unique system.
One of the most challenging aspects of building a CMS is customization. With this stack, PressUp can:
- Change backend logic
- Customize frontend
- Adjusting small parts
Not being limited by a framework, the system can be "fitted" to each customer. This is a major advantage in projects with highly specific requirements.
- Cost and operation: Less but more efficient
A good system not only runs well, but it must also be easy to operate. With this stack:
- Less dependence on rare technologies
- Easy to find staff
- Easy to maintain
This helps reduce long-term costs, not only in development but also in operation.
Conclusion: A philosophical choice, not just a technical one.
The choice of NodeJS, NextJS, and pure HTML was not a random decision. It reflects a clear vision for the web: **simple when possible, powerful when needed, and always in control**.
PressUp CMS Ultra doesn't try to chase trends, but focuses on building a sustainable platform. And in the rapidly changing world of technology, it is this sustainability that creates long-term value.
Ultimately, what matters isn't what technology you use, but whether that technology helps you master the system. And with PressUp, the answer is yes.
