When talking about CMS platforms in the .NET ecosystem, people often think of tools designed primarily to build websites. Orchard Core, however, was created with a different idea in mind: not just to manage content, but to serve as a foundation for building web software.

Orchard Core is an open-source project built on ASP.NET Core and represents a complete modern rewrite of the original Orchard CMS. The key difference is that it is not just a CMS: it is first and foremost a modular multi-tenant framework on top of which the content management system is built.

In practice, it can be used in two ways:

• as a traditional CMS
• as an application platform for building software products

This completely changes how it should be interpreted: it is not a direct competitor to classic website-focused CMS platforms, but a tool designed for projects meant to grow over time.

A CMS Designed as a Platform

The philosophy behind Orchard Core is simple: start minimal and add only what is needed.

Every feature is an activatable module. The result is a system that never becomes inherently heavy, because the application includes only the components actually in use.

This approach leads to two important consequences:

The first is technical: the codebase remains clean, maintainable, and upgradable even after years.

The second is architectural: the CMS becomes the foundation for complex applications, not just editorial websites.

Not surprisingly, the framework is also designed to build modular SaaS software, where multiple teams can develop different parts of the same product and reuse them across projects.

Multi-Tenant: The Feature That Changes Everything

The real core of Orchard Core is its native multi-tenancy.

With a single installation, it is possible to manage multiple completely separate sites: databases, users, themes, and configurations remain isolated. This is not simulated multisite functionality, but truly independent environments sharing only the engine.

This makes it particularly suitable for:

• SaaS platforms
• multi-brand corporate portals
• white-label solutions
• agencies managing many clients

In cloud environments, it is possible to host thousands of sites on a single infrastructure while maintaining full data isolation.

Performance and Modern Architecture

One of the main goals of the rewrite was speed.
The CMS was designed to leverage the ASP.NET Core pipeline and a data management approach different from traditional CMS platforms.

Although it uses relational databases, it adopts a document abstraction layer (YesSql) that allows content to be treated as documents, improving performance in typical CMS operations.

The result behaves much more like a web application than a traditional dynamic website.

Headless, Decoupled, or Traditional

One of Orchard Core’s most interesting qualities is architectural freedom.
It can be used in different ways without changing platforms:

• full website with themes and templates
• content backend for custom frontends
• headless CMS via GraphQL or REST APIs

In other words, it adapts to the project instead of forcing the project to adapt to the CMS.

Security

From a security perspective, Orchard Core inherits ASP.NET Core protections and adds highly granular permission management.

Each role can have specific access to content, administrative sections, and features. External authentication, approval workflows, and tenant isolation are supported.

This structure makes it suitable for enterprise and public-sector environments, where access management is often the critical factor.

Scalability and Cloud

Orchard Core was designed with scalability in mind from the very beginning, not added later.

It runs smoothly in Docker containers, cloud environments, and distributed architectures. Native multi-tenancy makes it easy to transform into the engine behind a software product.

It is therefore more accurate to compare it to an application platform with an integrated CMS rather than a simple editorial tool.

Scalability is one of the main reasons to choose Orchard Core:

• native multi-tenancy
• Docker container deployment
• cloud-ready architecture
• hosting thousands of sites in parallel
• per-client data isolation

Database and Flexible Data Management

It supports:

• SQL Server
• MySQL / MariaDB
• PostgreSQL
• SQLite

It uses a document-oriented abstraction layer (YesSql) on top of relational databases — an approach that improves performance in modern CMS environments.

In practice, it is designed more for platforms than for individual websites.

When It Makes Sense to Choose It

Orchard Core becomes particularly interesting when a project has these characteristics:

• it needs to grow over time
• it includes separate clients or environments
• it is intended to become a commercial product
• it requires integration with other systems
• it uses an enterprise .NET stack

SaaS and Platforms

• software delivered as a service
• customized customer portals
• white-label applications

Enterprise and Intranet

• document management
• approval workflows
• corporate portals

Headless CMS

• content backend for mobile apps
• React/Vue/Angular frontends
• custom ecommerce solutions

Multi-site

• brand networks
• publishing groups
• franchises

On the other hand, it is often oversized for small informational websites or simple blogs, where its real strengths would remain underutilized.

Community and Ecosystem

The community is not massive but highly technical and development-oriented.
The project is active, regularly updated, and maintained by experienced ASP.NET developers.

The documentation is extensive and geared more toward application developers than purely editorial users — another indication of its true nature.

Final Personal Considerations

Orchard Core is not an open-source CMS that can be evaluated at a glance: it appears to be a content management tool, but in reality it is an application platform that includes a CMS.

It is designed for complex web software, multi-client portals, and SaaS solutions. In these scenarios, it offers enormous advantages in terms of maintenance, scalability, and project organization.

If your goal is simply to publish content quickly, simpler solutions exist.
If instead you are building a system meant to last for years, it is likely exactly the kind of foundation worth starting from.

L'articolo Orchard Core: the Modular and Multi-Tenant .NET CMS for Scalable Applications proviene da Giovanni Anfuso.

Figma: what it is and why it has become a standard in digital design

Figma is a web-based UI/UX design tool used by designers, developers, and product teams to collaboratively create digital interfaces. Unlike traditional software, Figma works directly in the browser (with optional desktop apps) and allows multiple people to work simultaneously on the same file in real time.

Thanks to its simplicity, flexibility, and power, Figma has become a standard in product design, web design, and application development, adopted by both startups and large enterprises.

How Figma works

Figma is built on a cloud-first architecture. All files are saved online and accessible from anywhere, without the need for local versions or manual transfers.

Its main features include:

• Advanced vector editor for interface creation
• Real-time collaboration (similar to Google Docs)
• Reusable components and design systems
• Interactive prototyping without code
• Comments and feedback directly on the design
• Integrations and plugins to extend functionality

Technically, every user action is synchronized instantly with Figma’s backend, ensuring real-time updates for all collaborators.

Key advantages of Figma

Figma’s tremendous success comes from several key advantages:

1. Real-time collaboration
Multiple users can edit the same file simultaneously, eliminating version conflicts.

2. Accessibility
Being browser-based, Figma is accessible from any operating system without complex installations.

3. Performance and reliability
Even with complex files and large teams, Figma maintains high performance.

4. Scalable design systems
Components ensure visual consistency and speed up workflows.

5. Evolving ecosystem
Plugins, APIs, and integrations make Figma extremely extensible.

The scalability challenge: from a few users to over 10 million

With such rapid growth, Figma faced one of the toughest challenges for any SaaS platform: infrastructure scalability.

Initially, the team had to scale a monolithic PostgreSQL database designed for far fewer users than current volumes.

In a recent technical thread, Figma shared the journey from a single database to a horizontally sharded architecture capable of supporting over 10 million active users.

Phase 1: immediate relief with vertical scaling

The first phase addressed the most urgent issues:

• Vertical scaling of PostgreSQL
• Introduction of read replicas to reduce read load
• Connection pooling via PG Bouncer

These solutions provided a quick improvement but were insufficient for the long term.

Phase 2: stability with logical partitioning

In the medium term, Figma adopted logical partitioning, separating table groups into dedicated databases.

Notable innovations included:

• PostgreSQL views to simulate sharding
• Query testing on sharded structures before physical separation

During migration, the team optimized logical replication, temporarily removing indexes to speed up data transfer, drastically reducing migration time.

Phase 3: horizontal sharding and distributed architecture

The final phase achieved true scalability:

• Introduction of horizontal sharding
• Creation of a custom query router
• Development of a DB proxy in Golang for intelligent query routing across shards

Deployment occurred in two stages, using PG Bouncer to ensure safe transitions without downtime, allowing gradual and controlled traffic routing.

Why these optimizations matter

These optimizations are not just relevant for Figma—they are a key case study for anyone building high-growth SaaS applications.

They demonstrate how:

• PostgreSQL can scale to extremely high levels
• Incremental solutions are often more effective than full rewrites
• The combination of architectural choices and custom tooling can make a huge difference

Conclusion

Figma is not just a design tool but an excellent example of a well-engineered tech product, both in terms of user experience and backend architecture.

Its evolution, from a simple collaborative tool to a global platform serving millions of users, shows how innovation, performance, and scalability can coexist when technical decisions are guided by a clear, progressive vision.

For professionals in design, development, or software architecture, Figma remains an essential reference point.

L'articolo Figma: the design tool that keeps growing thanks to technological innovation proviene da Giovanni Anfuso.