Why did PressUp choose PostgreSQL + JSONB as the data platform for its Ultra CMS?
When building CMS Ultra, PressUp didn't follow the common path of choosing a purely relational or purely NoSQL database. Instead, they opted for PostgreSQL combined with JSONB – a seemingly "middle ground" choice, but one that actually strikes a very good balance between structure and flexibility. This wasn't a random decision, but the result of a clear understanding of the problem: building a system that could be customized for each client while maintaining consistency and data control.
In the architecture of any web system, the database is always the silent but crucial core. Users may not see it, but everything – from content, customers, orders to behavior – passes through and is stored there. Therefore, choosing a database is not just a technical decision, but a strategic one, directly impacting the scalability, flexibility, and stability of the entire system.
- The data problem: Where "structure" and "flexibility" always conflict.
In system design, data always lies between two extremes. On one side is clearly structured data, easy to control and query – often handled well by relational databases like PostgreSQL and MySQL. On the other side is dynamic data, changing on a case-by-case basis, difficult to define in advance – where NoSQL systems like MongoDB excel.
The problem is, in reality, the system doesn't just handle one type of data. A CMS like PressUp CMS Ultra has to handle both:
- Standard data such as users, orders, and permissions.
- Flexible data such as content configuration, customizable fields, metadata
If you choose a purely relational system, it will become rigid and difficult to scale. If you choose a purely NoSQL system, control and querying will become complex, especially when consistency is required.
Therefore, the problem is not about choosing one side, but about finding a way to reconcile both.
- PostgreSQL: The stability of a mature database management system.
PostgreSQL is one of the most powerful and long-standing relational database management systems. It is known for:
- Stability
- Transaction processing capability
- Supports complex queries
For CMS Ultra, this is the necessary foundation for handling "backbone" data:
- User account
- Delegation of authority
- Order
- System logs
These data require high accuracy, cannot be falsified, and need to be secured by transaction mechanisms.
PostgreSQL handles this well. But if it stops there, it's still not enough for the flexibility requirements of PressUp.
- JSONB: Unlocking Flexibility in PostgreSQL
JSONB is a special feature of PostgreSQL that allows data to be stored in JSON format, but with higher performance and indexing capabilities compared to regular JSON.
The key point is that JSONB doesn't break the structure of the relational database, but extends it. This allows:
- Store data flexibly in a column
- Query JSON data as part of SQL
- Create indexes on fields within JSON.
With JSONB, PostgreSQL is no longer a "hardware" system, but becomes a hybrid platform combining relational and document-based elements.
This is where PressUp takes advantage.
- One system, two layers of data: Structure and extension
In CMS Ultra, data is organized into two layers:
- Structure layer: traditional relational tables
- Extension class: flexible JSONB fields
For example, a product might have standard fields like name, price, and status. But detailed descriptions, unique attributes, or display configurations can be stored in JSONB.
This helps the system:
- Maintaining consistency for critical data
- Flexible scaling for customized data
There's no need to create new tables for each change, nor is there a need to break the old schema.
- Customer-specific customization: No need to change the database structure.
One of the defining characteristics of PressUp CMS Ultra is that each client has a different system. This creates a significant challenge: how to support customization without constantly changing the database?
With JSONB, many types of data can be stored in a flexible format:
- Custom field
- Interface configuration
- Metadata
This allows the system to adapt quickly to new requirements without complex migrations.
This is a huge advantage in a real-world environment where constant change is required.
- Powerful queries: No compromise between flexibility and performance.
One of the concerns when using JSON data is queryability. But PostgreSQL with JSONB allows it:
- Query fields directly in JSON
- Combined with SQL
- Create an index to speed things up.
This helps the system avoid having to compromise between flexibility and performance.
The data should be both flexible and quickly retrievable when needed.
- Integration and APIs: When data is no longer "confined"
In a modern system, data doesn't just reside in a database; it also needs to be accessible externally via APIs.
JSONB makes this work more naturally:
- Data can be serialized directly.
- No complicated conversion required
- Easy to integrate with frontend and other systems
This is particularly relevant to the NodeJS and NextJS architecture that PressUp uses.
- Reduced complexity: Fewer tables, fewer migrations
A purely relational system typically requires many tables to represent different data structures. This leads to:
- Complex schema
- Migration is difficult.
- Difficult to maintain
With JSONB, multiple data sets can be grouped together logically. This helps to:
- Reduce the number of tables
- Reduce dependencies between tables
- Easier to change
This is a form of "controlled simplification".
- Sustainability: A Choice for the Present and the Future
A good system not only solves current problems but also needs to be prepared for the future.
PostgreSQL + JSONB provides:
- Long-term stability
- Scalability
- Flexibility
As the system evolves, the data can change without needing to rebuild from scratch.
This is a major advantage, especially for highly customizable systems like CMS Ultra.
Conclusion: Not the most popular choice, but the most suitable.
PressUp didn't choose PostgreSQL + JSONB because it's the most popular, but because it best suited their problem.
That's the problem:
- It needs structure, but not rigidity.
We need to be flexible but not lose control.
- Needs expansion, but not complexity.
In the world of technology, there are no perfect choices. But there are choices that strike a better balance of many factors.
And PostgreSQL + JSONB is just such a choice – a platform robust enough to serve as a cornerstone, yet flexible enough to adapt to change. For PressUp CMS Ultra, it wasn't just a technical decision, but part of a philosophy: **building systems that can grow without constraints**.
