Forem: Maurizio Turatti

Facet: The data-driven Web framework

Maurizio Turatti — Tue, 10 Feb 2026 11:12:59 +0000

Facet is a new kind of Web Framework: it transforms JSON into server-rendered HTML using path-based templates. Templates simply mirror your API structure. The same endpoint serves JSON to clients and HTML to browsers.

Building Data-Driven Web Apps Without the Backend Complexity

Facet brings Java's production-grade reliability with PHP's rapid development experience. Map MongoDB collections to HTML templates through convention, no controllers, no ORMs. Hot reload during development, deploy as a single JAR or native binary with sub-100ms startup.

The Problem

Modern web development forces you to choose:

Spring Boot? Powerful but complex—controllers, services, repositories, configuration files, dependency injection
Laravel/Django/Rails? Fast development but requires careful operational tuning for production scale
Modern SPAs? Build separate frontend and backend, manage state, loading states, API orchestration
Headless CMS? Pay for features you don't need, locked into proprietary systems

What if you could get Java's performance with PHP's simplicity?

Meet Facet

Facet is a data-driven web framework that transforms MongoDB REST APIs into server-rendered HTML. Convention over configuration means your collections become web pages automatically—no backend code needed.

Hybrid API/UI from the same endpoint:

# JSON for APIs
curl -H "Accept: application/json" http://localhost:8080/shop/products

# HTML for browsers  
curl -H "Accept: text/html" http://localhost:8080/shop/products

The same code, same data, different representation. Templates are opt-in—add HTML rendering only where you need it. Your REST API remains unchanged.

How It Works

1. Convention-Based Template Resolution

Your template structure mirrors your API paths:

Request: GET /shop/products
         Accept: text/html

Facet looks for:
1. templates/shop/products/index.html   ✓ (found!)
2. templates/shop/index.html            (parent fallback)
3. templates/index.html                 (global fallback)
4. No template → return JSON            (API unchanged)

SSR is opt-in per resource. Add templates only where you need HTML.

2. Rich Template Context

Templates automatically receive:

<h1>{{ database }}/{{ collection }}</h1>

{% for item in items %}
  <div class="product">
    <h3>{{ item.data.name }}</h3>
    <p>{{ item.data.description }}</p>
    <span>${{ item.data.price }}</span>
  </div>
{% endfor %}

{# Pagination built-in #}
{% if totalPages > 1 %}
  <nav>
    {% for p in range(1, totalPages + 1) %}
      <a href="?page={{ p }}">{{ p }}</a>
    {% endfor %}
  </nav>
{% endif %}

Context includes: pagination, authentication, permissions, MongoDB query parameters, and more.

3. First-Class HTMX Support

Facet automatically detects HTMX requests and routes to fragment templates:

Full page template:

{% extends "layout" %}

{% block main %}
  <div id="product-list">
    {% include "_fragments/product-list" %}
  </div>

  <form hx-get="/shop/products"
        hx-target="#product-list"
        hx-indicator="#loading">
    <input name="filter" placeholder="Search...">
    <button type="submit">Search</button>
  </form>
{% endblock %}

Fragment template (templates/_fragments/product-list.html):

{% for item in items %}
  <article>
    <h3>{{ item.data.name }}</h3>
    <p>{{ item.data.description }}</p>
    <span>${{ item.data.price }}</span>
  </article>
{% endfor %}

When HTMX sends HX-Target: #product-list, Facet automatically renders just the fragment—no backend code needed.

Quick Start

1. Start Facet and MongoDB

curl -O https://getfacet.org/docker-compose.yml
docker-compose up -d

2. Create Database and Add Data

# Create collection
curl -X PUT http://localhost:8080/shop/products

# Insert products
curl -X POST http://localhost:8080/shop/products \
  -H "Content-Type: application/json" \
  -d '[
    {"name": "Laptop", "price": 999},
    {"name": "Mouse", "price": 29}
  ]'

3. Create Template

mkdir -p templates/shop/products

templates/shop/products/index.html:

<!DOCTYPE html>
<html>
<head>
  <title>Products</title>
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/pico.min.css">
  <script src="https://unpkg.com/htmx.org@2.0.8"></script>
</head>
<body>
  <main class="container">
    <h1>Products</h1>

    <div id="product-list">
      {% for item in items %}
        <article>
          <h3>{{ item.data.name }}</h3>
          <span>${{ item.data.price }}</span>
        </article>
      {% endfor %}
    </div>
  </main>
</body>
</html>

4. Visit in Browser

open http://localhost:8080/shop/products

✨ That's it! You have a working web application with zero backend code.

Real-World Example

The product catalog example demonstrates a complete application with:

✅ MongoDB data binding and display
✅ Search and filtering with MongoDB queries
✅ Pagination with preserved query parameters
✅ HTMX partial updates for dynamic search
✅ Authentication & role-based access control
✅ Full CRUD operations (admin only)

Try it yourself:

git clone https://github.com/SoftInstigate/facet.git
cd facet/examples/product-catalog
docker-compose up

Visit http://localhost:8080/shop/products

The example includes hot-reload—edit templates and see changes instantly without restart.

Why This Approach?

For Simple Projects

No backend coding - Templates directly render API data
Convention over configuration - No route wiring, templates map to URLs automatically
Hot reload - Edit templates, refresh browser, see changes instantly (no build step, no webpack, no npm scripts)
Progressive enhancement - Start with JSON API, add HTML where needed

For Complex Projects

Flexible layouts - Different layouts per application area
Framework agnostic - Use any CSS/JS framework (React, Alpine.js, Tailwind, etc.)
HTMX native - Build SPA-like experiences with server-side rendering
SEO friendly - Server-rendered HTML from the start
Extensible - Add custom logic via RESTHeart plugins (Java or JavaScript via GraalVM)

For Teams

Separation of concerns - Web devs work on templates, backend devs on API
No deployment coupling - Templates update without backend changes
Gradual adoption - Add HTML to existing APIs incrementally

Architecture Benefits

Facet leverages RESTHeart's production-grade features:

MongoDB REST API with full query support
Authentication (JWT, Basic Auth, OAuth, LDAP)
Authorization with fine-grained ACL
WebSocket and Change Streams for real-time data
GraphQL support (coming soon to Facet templates)
Plugins for custom business logic

You get enterprise-grade infrastructure without building it yourself.

When to Use Facet

Great fit:

✅ Content-driven applications (blogs, catalogs, dashboards)
✅ Internal tools and admin panels
✅ MongoDB-backed applications
✅ Projects prioritizing SEO and fast initial load
✅ Teams wanting to avoid frontend/backend coordination

Not ideal for:

❌ Highly interactive applications with complex client-side state
❌ Non-MongoDB databases (Facet is MongoDB-specific)
❌ Applications requiring real-time collaboration (though RESTHeart supports WebSockets)

How Does Facet Compare?

vs. Spring Boot and Java MVC Frameworks

Spring Boot is powerful but complex: controllers, services, repositories, configuration files, build tools, and dependency injection.

Facet eliminates this boilerplate:

✅ MongoDB collections automatically become web pages through convention-based templates
✅ No controllers, no ORMs, no XML configuration
✅ Hot reload templates without restart
✅ Get Java's performance without Java's ceremony

Performance: Same JVM benefits (sub-100ms startup with native images, ~50MB memory footprint, handle thousands of concurrent connections)

When to use Spring Boot instead: Complex business logic requiring extensive service layers, non-MongoDB databases, or team already invested in Spring ecosystem

vs. Laravel, Django, Rails

PHP and Python frameworks are great for rapid development, but they require careful operational tuning for production scale.

Facet gives you the same rapid development experience:

✅ Convention over configuration
✅ Hot reload during development
✅ Minimal boilerplate

But runs on the battle-tested JVM:

✅ Deploy with confidence—no PHP-FPM tuning, no WSGI complexity
✅ Sub-100ms startup with native images
✅ ~50MB memory footprint
✅ Handle thousands of concurrent connections out of the box

When to use Laravel/Django instead: Team expertise in PHP/Python, need for framework-specific packages, or using PostgreSQL/MySQL

vs. Modern SPAs (React, Vue, Angular)

SPAs excel at highly interactive applications but add complexity:

Facet simplifies:

✅ Server-rendered HTML by default (SEO-friendly from day one)
✅ No state management, loading states, or API orchestration needed
✅ HTMX for SPA-like interactivity without build tools
✅ Progressive enhancement—add interactivity where needed

When to use SPAs instead: Highly interactive applications with complex client-side state (think Gmail, Figma, or real-time collaboration tools)

vs. Headless CMS (Contentful, Strapi)

Headless CMSs provide content modeling and APIs:

Facet offers:

✅ More flexibility—not limited to content modeling paradigms
✅ Direct MongoDB access with full query power
✅ Open source—run anywhere, no vendor lock-in
✅ No licensing costs

When to use Headless CMS instead: Non-technical content editors need a UI, or you need advanced content workflows and localization

Performance & Deployment

Choose Your Runtime

GraalVM JDK (with JavaScript extensibility):

~1s startup time
~150MB memory footprint
Support for JavaScript plugins via GraalVM

Native Image (maximum performance):

<100ms startup time
~50MB memory footprint
Single binary, no Java installation required

Both configurations handle thousands of concurrent requests efficiently. MongoDB queries stream directly to templates—no ORM overhead.

Production Features

Template caching - Compiled templates cached for optimal performance
ETag support - Browser caching with 304 Not Modified responses
MongoDB indexes - RESTHeart leverages your database indexes
Stateless design - Horizontal scaling is trivial
Single artifact - Deploy as JAR or native binary
12-factor compliant - Environment-based configuration, health checks built in

Deployment Options

Deploy anywhere:

Docker containers
Kubernetes clusters
AWS, Azure, Google Cloud
Bare metal servers

Getting Started

Documentation: https://getfacet.org/docs

GitHub: https://github.com/SoftInstigate/facet

Examples: Product Catalog Tutorial

RESTHeart Docs: https://restheart.org/docs

License

Facet is Apache 2.0 licensed—free for commercial use. Built on RESTHeart (AGPL v3 core, Apache 2.0 plugin interfaces).

Conclusion

Facet brings together the best of two worlds: Java's production-grade reliability and performance with the rapid development experience of PHP or Python frameworks. Convention over configuration, hot reload during development, deploy as a single JAR or native binary.

If you're building data-driven applications and want to skip the backend boilerplate while maintaining production-grade performance, give Facet a try.

Quick start:

curl -O https://getfacet.org/docker-compose.yml
docker-compose up -d

Or explore the product catalog example:

git clone https://github.com/SoftInstigate/facet.git
cd facet/examples/product-catalog
docker-compose up

Side effects of AI on open source

Maurizio Turatti — Mon, 19 Jan 2026 09:20:29 +0000

One of the side effects of massive AI adoption in programming is how that impacts some open source projects.

Tailwind CSS is a successful CSS library. Unlike other frameworks, like Bootstrap, it does not provide a series of predefined classes for elements such as buttons or tables. Instead, it creates a list of "utility" CSS classes that can be used to style each element by mixing and matching.

AI is creating pressure on the commercial offering from Tailwind because it is now easy for AI to recombine the elements to create full web components. So no reasons to buy their high-level commercial components.

I've seen this firsthand. While building a new website with AI assistance, I didn't use any CSS framework at all. The AI generated custom, responsive styles from scratch, and the results are clean and professional.

According to this article, Tailwind has faced significant challenges from this shift, though they've recently secured backing from Google, Vercel, and Lovable to adapt their model.

This raises a bigger question: if AI can generate what you used to sell, how do open source projects sustain themselves commercially? The old model of "free core + paid convenience layer" may need rethinking when AI provides that convenience layer for free.

Is Java a verbose programming language?

Maurizio Turatti — Tue, 23 Dec 2025 08:55:49 +0000

Short answer: Most complaints about Java’s verbosity are based on Java 8-era Java. Since 2014, the language has evolved significantly, and many of those criticisms no longer hold.

Why the “Java is verbose” criticism is outdated

People usually mean three things by “verbose,” all of which were largely true in Java 8:

Boilerplate-heavy data modeling
Clumsy control flow
Ceremonial program structure

The real issue

Most people forming opinions about Java today are:

using Java 8 at work
reading Java 8-era tutorials
comparing Java 8 code to modern Kotlin / Python / Go

That’s like judging JavaScript today based on ES5.

The uncomfortable truth

Modern Java is:

still explicit
still strongly typed
still conservative

…but it is no longer excessively verbose relative to other mainstream, production-grade languages.

The criticism persists mainly because:

enterprises stayed on Java 8 for years
cultural perception lagged behind language evolution
Java optimizes for long-lived systems, not hype cycles

Below a compact example of new Java features:

record User(String name, int age) {}

void main() {
    var user = new User("Alice", 32);

    String category = switch (user) {
        case User(_, int age) when age < 18 -> "minor";
        case User(_, int age) when age < 65 -> "adult";
        case User(_, _)                     -> "senior";
    };

    System.out.println("""
        User info
        ---------
        Name: %s
        Age: %d
        Category: %s
        """.formatted(user.name(), user.age(), category));
}

Why this example is interesting

No class declaration Java finally supports script-like programs without sacrificing type safety.
record Immutable data carrier, perfect for domain objects and DTOs.
Pattern matching in switch No getters, no casts, no if-else chains.
Text blocks Cleaner multiline output without escaping noise.
Still 100% Java This is not a toy language mode.

Compile & run

Copy and Save the above code into a file, say Main.java. To compile and run:

~ javac Main.java
~ java Main
User info
---------
Name: Alice
Age: 32
Category: adult

Bottom line

If someone says “Java is verbose” and hasn’t seriously looked at Java post-17, they’re not making a technical argument, they’re repeating a historical one.

PostgREST vs RESTHeart

Maurizio Turatti — Wed, 17 Dec 2025 11:16:20 +0000

A Comprehensive Comparison of Database-to-API Frameworks

In the world of modern application development, one challenge consistently surfaces: how to quickly and efficiently expose database operations through RESTful APIs. Two powerful open-source solutions tackle this problem from different angles: PostgREST for PostgreSQL and RESTHeart for MongoDB. While they share a common philosophy of automatic API generation, they serve distinct database ecosystems and offer unique architectural approaches.

The Core Philosophy: Database-First Development

Both PostgREST and RESTHeart embrace a "database-first" philosophy that fundamentally differs from traditional API development approaches. Instead of writing controllers, routes, and data access layers manually, both frameworks treat the database schema itself as the single source of truth. This approach eliminates the impedance mismatch between your data model and your API, reduces boilerplate code, and ensures that your API always reflects your current database structure.

The key insight driving both projects is that most CRUD operations don't require custom business logic. By delegating these repetitive tasks to a specialized layer that understands your database, you can focus on implementing the features that make your application unique.

PostgREST: Turning PostgreSQL into a REST API

PostgREST is a standalone web server written in Haskell that automatically generates a RESTful API from any PostgreSQL database. Simply point it at your database, and it introspects the schema to create corresponding HTTP endpoints.

Core Capabilities

PostgREST offers comprehensive database operations through HTTP verbs. Standard CRUD operations map naturally to GET, POST, PUT, PATCH, and DELETE requests. The framework supports complex queries through URL parameters, allowing filtering, sorting, pagination, and even joins without writing a single line of backend code.

For example, querying with filters looks like this:

GET /students?age=gt.18&order=name.asc&limit=10

PostgREST translates these URL parameters directly into optimized PostgreSQL queries, leveraging the database's query planner for maximum performance.

Security Model

One of PostgREST's most compelling features is how it handles security. Rather than implementing authorization logic in the API layer, PostgREST leverages PostgreSQL's role-based access control system. When a request arrives with JWT credentials, PostgREST assumes the corresponding PostgreSQL role for that connection, ensuring the database itself enforces all permissions.

This approach provides several advantages. You define security rules once in the database using standard SQL GRANT statements and Row-Level Security policies. There's no application-layer code that could bypass database constraints. Security becomes declarative and centralized, making it easier to audit and maintain.

Architecture and Performance

Built on Haskell and the Warp HTTP server, PostgREST benefits from a highly efficient compiled language. It uses connection pooling through the Hasql library and PostgreSQL's binary protocol to minimize serialization overhead. The framework delegates as much work as possible to PostgreSQL itself, including JSON serialization, data validation, and authorization checks.

This design results in exceptional performance. Teams have reported dramatic improvements when migrating from traditional ORM-based APIs, with some seeing 10x speed increases and massive reductions in memory usage compared to their previous implementations.

API Versioning and Documentation

PostgREST handles API versioning elegantly through PostgreSQL schemas. You can expose different versions of your API by creating separate schemas with different views on the underlying tables. This allows you to evolve your data model without breaking existing clients.

The framework automatically generates OpenAPI specifications for your API, which can be rendered with tools like Swagger UI for interactive documentation. This means your API documentation is always in sync with your actual database structure.

Limitations and Considerations

PostgREST deliberately maintains a focused scope. It excels at CRUD operations but leaves concerns like sending emails, complex business logic, or integration with external services to other tools. You'll need to combine PostgREST with additional components (like Nginx for routing, custom PostgreSQL functions for complex operations, or separate microservices for non-CRUD functionality) to build complete applications.

There's also no native GUI for managing configurations, and while the API documentation can be generated from the OpenAPI spec, this requires additional setup.

RESTHeart: The MongoDB Backend Framework

RESTHeart takes a broader approach as a full-featured Java backend framework that provides instant REST, GraphQL, and WebSocket APIs for MongoDB. While PostgREST focuses narrowly on REST operations, RESTHeart positions itself as a comprehensive application framework.

Multi-Protocol Support

Unlike PostgREST's REST-only approach, RESTHeart natively supports three different protocols for accessing MongoDB data. The REST API provides the same automatic CRUD operations you'd expect, with support for filtering, pagination, sorting, and aggregations. The GraphQL API allows you to define schemas and queries through configuration rather than code. The WebSocket API enables real-time updates and change streams, notifying clients when data changes without requiring polling.

"Query": {
    "countPostsByCategory": {
      "db": "restheart",
      "collection": "users",
      "stages": [
        { "$group": { "_id": "$category", "count": { "$count": {} }}
      ]
    }
 }

This multi-protocol design makes RESTHeart particularly well-suited for modern applications that need real-time features alongside traditional request-response patterns.

Extensibility Through Plugins

RESTHeart's plugin architecture distinguishes it from PostgREST's minimalist approach. The framework provides four plugin types: Services (custom endpoints), Interceptors (request/response transformers), Providers (dependency injection), and Initializers (startup tasks).

Plugins can be written in Java, Kotlin, JavaScript, or TypeScript, giving teams flexibility in their technology choices. The restheart-core runtime handles plugin loading, configuration parsing, security enforcement, and request routing. Pre-built plugins for MongoDB operations, GraphQL support, and security come bundled with the distribution.

@RegisterPlugin(
  name = "kotlinGreeterService", 
  defaultURI = "/greetings", 
  description = "just another Hello World in Kotlin")
class GreeterService : JsonService {
    override fun handle(req: JsonRequest, res: JsonResponse) {
        when(req.method) {
            METHOD.GET -> res.content = obj().put("msg", "Hello World").get()
            METHOD.OPTIONS -> handleOptions(req);
            else -> res.setStatusCode(HttpStatus.SC_METHOD_NOT_ALLOWED);
        }
    }
}

This architecture allows RESTHeart to grow with your application. You can start with zero-code APIs and progressively add custom logic through plugins as requirements evolve.

Security and Authentication

RESTHeart includes comprehensive authentication and authorization features out of the box. Multiple authentication mechanisms are supported, including JWT, Basic Auth, and custom authenticators. Authorization can be configured through Access Control Lists with fine-grained permissions, integration with MongoDB roles, and request predicates for conditional access.

{
  "_id": "userCanGetOwnCollection",
  "roles": ["user"],
  "predicate": "method(GET) and path-template('/{userid}') and equals(@user._id, ${userid}) and qparams-contain(page) and qparams-blacklist(filter, sort)",
  "priority": 100,
  "mongo": {
    "readFilter": { "_$or": [{ "status": "public" }, { "author": "@user._id" }] },
    "projectResponse": { "log": 0 }
  }
}

User and permission management happens directly in MongoDB collections, eliminating the need for separate user databases or authentication services. This streamlined approach significantly reduces development time for applications with standard security requirements.

Performance and Deployment

Built on Undertow (the web server powering Red Hat's WildFly applpication server) and fully embracing Java 21's virtual threads, RESTHeart achieves impressive performance characteristics. Virtual threads enable efficient handling of thousands of concurrent connections without the complexity of traditional async programming.

The framework starts in approximately 100 milliseconds and has a small memory footprint (around 10MB for the JAR, 50MB when compiled to native). Each request runs in its own dedicated thread, making code simple and thread-safe by default.

RESTHeart supports multiple deployment options: as a standalone JAR, as a Docker container, compiled to a GraalVM native binary, or through RESTHeart Cloud (a fully managed service). The stateless architecture enables horizontal scaling across multiple instances.

MongoDB Feature Coverage

RESTHeart exposes MongoDB's full capabilities through its APIs. This includes advanced features like aggregation pipelines, transactions (when MongoDB runs as a replica set), GridFS for binary file storage, schema validation, indexes, and even change streams for real-time data.

The framework works not just with MongoDB but also with compatible databases like FerretDB (which provides MongoDB compatibility for PostgreSQL), AWS DocumentDB, and Azure Cosmos DB.

License Considerations

RESTHeart uses dual licensing: AGPL for open-source use and a Business Friendly Enterprise License for commercial applications. The AGPL version has no feature restrictions, but organizations building closed-source products typically need the Enterprise License.

Key Similarities

Despite targeting different databases, PostgREST and RESTHeart share several fundamental characteristics:

✅ Zero-Code Data APIs: Both eliminate the need to manually code CRUD endpoints, automatically generating APIs from database schemas.

✅ Database-Centric Security: Both leverage the database's native security features rather than implementing authorization in application code.

✅ Declarative Configuration: Most functionality comes from database schema and simple configuration rather than imperative programming.

✅ Performance Focus: Both achieve high throughput by delegating work to the database and using efficient underlying technologies.

✅ Open Source with Commercial Options: Both offer open-source licenses with commercial support options available.

Key Differences

Database Targets

The most obvious difference is database compatibility. PostgREST exclusively supports PostgreSQL (and must support its wire protocol). RESTHeart targets MongoDB and MongoDB-compatible databases. This isn't just a connection string change; it reflects fundamentally different data models (relational vs. document-oriented) with distinct query capabilities, transaction semantics, and schema approaches.

Architectural Scope

PostgREST maintains a deliberately narrow focus on REST API generation. It does one thing extremely well and expects you to combine it with other tools for additional functionality. This Unix philosophy approach provides simplicity and composability.

RESTHeart takes a framework approach, providing a broader set of built-in features including multiple API protocols, plugin systems, and application-level functionality. It aims to be a complete backend platform rather than just an API gateway.

Programming Languages and Ecosystem

PostgREST is written in Haskell, leveraging functional programming concepts and the Warp server's efficiency. While you don't need to know Haskell to use it, extending PostgREST typically means writing PostgreSQL functions and using other ecosystem tools.

RESTHeart runs on the JVM, is written in Java, and supports plugin development in Java, Kotlin, JavaScript, and TypeScript. This aligns with the extensive Java enterprise ecosystem and makes it more approachable for teams already working in these languages.

Security Implementation

Both emphasize database-native security, but the implementations differ. PostgREST's JWT-to-PostgreSQL-role mapping creates a direct connection between authentication tokens and database permissions. Every request runs under a specific PostgreSQL role with its associated privileges.

RESTHeart provides a more traditional security layer with built-in authentication mechanisms and ACL-based authorization, while also supporting MongoDB role integration. This offers more flexibility but adds a security layer between clients and the database.

API Protocols

PostgREST focuses exclusively on REST over HTTP, generating endpoints that follow RESTful conventions. RESTHeart supports REST, GraphQL (with configurable schemas), and WebSockets for real-time updates, providing more options for client applications with different requirements.

Extension Models

PostgREST's extension points are primarily PostgreSQL functions and views, combined with external tools handling concerns outside CRUD operations. This keeps the core simple but requires architectural planning.

RESTHeart's plugin system provides formalized extension points with Java/JavaScript code, dependency injection, and lifecycle management. This makes adding custom business logic more straightforward within the framework itself.

Use Case Recommendations

Choose PostgREST When You

Have an existing or planned PostgreSQL database
Need a lightweight, focused REST API layer
Want to leverage PostgreSQL's advanced features (foreign keys, complex queries, stored procedures)
Prefer a minimalist architecture with composable tools
Have strong SQL skills and want database-driven development
Value the simplicity of having security defined entirely in the database
Don't need GraphQL or WebSocket support
Can handle additional concerns (email, file storage, etc.) through other services

Choose RESTHeart When You

Work with MongoDB or need a document database
Want multiple API protocols (REST, GraphQL, WebSockets) from one backend
Need real-time data updates through change streams
Prefer an all-in-one framework over composing multiple tools
Work in Java/JVM ecosystems
Want to write custom business logic in Java, Kotlin, or JavaScript
Need a rapid application development platform with minimal setup
Want to progressively add complexity through plugins as requirements grow
Require flexible schema evolution and document-oriented data modeling

Performance Considerations

Both frameworks deliver excellent performance, though measuring them directly against each other would be comparing apples to oranges given their different database targets.

PostgREST benefits from Haskell's efficiency, PostgreSQL's mature query planner, and aggressive delegation of work to the database. Teams report handling thousands of requests per second with minimal resource usage.

RESTHeart leverages Java virtual threads for efficient concurrency, Undertow's high-performance HTTP handling, and MongoDB's scalable architecture. The framework can handle hundreds of thousands of transactions per second in optimized deployments.

For most applications, the database itself will be the bottleneck rather than the API framework, making your choice of database more significant than the framework's raw performance characteristics.

Development Experience

PostgREST Workflow

Development with PostgREST centers on your PostgreSQL schema. You design tables, create views, define functions, and set up permissions using SQL. The API emerges automatically from these definitions. Testing often happens directly in PostgreSQL before making HTTP requests.

The workflow emphasizes database skills. If you're comfortable with SQL and relational modeling, PostgREST's approach feels natural. If your team struggles with advanced SQL, the learning curve may be steeper.

RESTHeart Workflow

RESTHeart development typically starts with zero configuration. Connect it to MongoDB, and you can immediately start creating collections and documents through the REST API. As requirements grow, you add configuration for relationships, validation schemas, or GraphQL mappings. Eventually, you might develop custom plugins for business logic.

This progressive complexity model allows teams to start quickly and add sophistication gradually. The framework supports both low-code and code-heavy approaches depending on application requirements.

Community and Ecosystem

PostgREST has an active open-source community on GitHub with contributions from developers worldwide. The project maintains solid documentation, and its focused scope means the API surface is relatively stable. Commercial support is available through Patreon supporters and third-party consultants.

RESTHeart is developed by SoftInstigate, which provides both open-source AGPL licensing and commercial enterprise licensing with professional support. The project has comprehensive documentation, tutorials, and example applications. The commercial backing provides long-term stability and professional support options.

Migration and Integration

Integrating PostgREST

PostgREST integrates well with existing PostgreSQL databases. You can start with a read-only API by creating views and gradually expand to write operations. The framework works alongside traditional applications, making incremental adoption feasible.

Common integration patterns include using Nginx as a reverse proxy for routing, combining PostgREST with other microservices for non-CRUD operations, and leveraging PostgreSQL NOTIFY/LISTEN for real-time features through external tools.

Integrating RESTHeart

RESTHeart can connect to existing MongoDB deployments without schema modifications. Since MongoDB is schema-less, you can immediately expose existing collections through the API with automatic CRUD operations.

The framework's plugin system facilitates integration with existing Java applications, and the multi-protocol support makes it easier to serve different client types (web, mobile, real-time) from a single backend.

Conclusion

PostgREST and RESTHeart represent mature, production-ready approaches to automatic API generation, each tailored to its respective database ecosystem. They share a vision of database-first development that eliminates boilerplate code and embraces declarative data modeling.

PostgREST's minimalist, focused approach makes it ideal for teams comfortable with PostgreSQL who want a lightweight API layer that leverages the database's full power. Its Unix philosophy of doing one thing well, combined with PostgreSQL's robustness, creates a compelling platform for data-centric applications.

RESTHeart's comprehensive framework approach provides everything needed for MongoDB-based applications out of the box. The multi-protocol support, plugin architecture, and progressive complexity model make it excellent for teams wanting rapid development without sacrificing the ability to add custom logic when needed.

Your choice between them primarily depends on your database selection, which itself should be driven by your data model, query patterns, and scalability requirements. If you need PostgreSQL's relational capabilities, ACID guarantees, and SQL power, PostgREST is the clear choice. If MongoDB's document model, flexible schema, and horizontal scalability fit your needs, RESTHeart provides an exceptional backend platform.

Both projects prove that the tedious work of building CRUD APIs can be automated, freeing developers to focus on what makes their applications unique. In a world where time-to-market and developer productivity are critical, these frameworks represent a significant evolution in how we build data-driven applications.

Resources

PostgREST

Documentation: https://postgrest.org/
GitHub: https://github.com/PostgREST/postgrest
License: MIT

RESTHeart

Documentation: https://restheart.org/docs/
GitHub: https://github.com/SoftInstigate/restheart
License: AGPL / Enterprise (dual license)
Commercial: https://cloud.restheart.com/

REST API for PostgreSQL with RESTHeart and FerretDB

Maurizio Turatti — Fri, 06 Oct 2023 13:11:35 +0000

This tutorial introduces FerretDB, an open-source alternative to MongoDB built on PostgreSQL. Utilizing FerretDB in conjunction with RESTHeart, a powerful API server for MongoDB, this guide demonstrates how to set up the FerretDB stack using Docker and interact with it using RESTHeart's REST API.

The tutorial covers creating databases, populating collections, querying and updating documents, providing an efficient and compatible MongoDB-like experience while leveraging the benefits of PostgreSQL for storage and management.

Read the full article.

Real-time Web chat example with Angular and MongoDB

Maurizio Turatti — Fri, 16 Jul 2021 14:33:07 +0000

We have developed an example Web application made with Angular 12 that uses RESTHeart WebSockets with MongoDB Change Streams to provide an instant, zero lines of code API for a realtime chat application:

https://chat.restheart.org

In short, RESTHeart leverages MongoDB's Change Streams to instantly notify database modifications to clients (Web or Mobile apps), through the WebSocket protocol.

RESTHeart is an open-source runtime and a low-code SDK for Microservices with declarative security and instant Data APIs on MongoDB or any compatible database (e.g. Percona Server for MongoDB, AWS DocumentDB and Azure Cosmos DB).

The complete source code of this Angular Web application is available on GitHub. The most interesting thing, IMO, is that the server-side source code necessary to deploy this example is zero. You need to start MongoDB, configure RESTHeart and just start writing client-side code.

Below an article which describes this demo with more details:

https://www.softinstigate.com/en/blog/posts/restheart-webchat/

Softinstigate’s RESTHeart API for MongoDB simplifies development and frees you to focus on delivering great user experiences

Maurizio Turatti — Tue, 13 Apr 2021 16:10:22 +0000

RESTHeart is a stateless REST API microservice for MongoDB, written in Java and embedding the Undertow HTTP server, that lets users access the full power of MongoDB using HTTP calls. No server-side coding frees developers to focus on developing innovative, value-adding apps.

Read the full article here: https://www.mongodb.com/customers/softinstigate

RESTHeart - Modern runtime for microservices - Video

Maurizio Turatti — Sat, 12 Dec 2020 11:16:56 +0000

This video introduces RESTHeart, a modern, open source backend for microservices that can expose instant APIs for MongoDB.

RESTHeart - a Java runtime for microservices

Maurizio Turatti ・ Nov 23 '20

#java #microservices #mongodb #webdev

RESTHeart - a Java runtime for microservices

Maurizio Turatti — Mon, 23 Nov 2020 14:20:16 +0000

In 2014 we had long realized that both Java application servers and frameworks force people to invest a lot of time in their configuration and maintenance, comparing to what is usually invested in the implementation of actual functionalities.

For these reasons, at our company we started developing an open-source product called RESTHeart, in order to investigate more rational ways to build applications. It was born as a summer experiment and it became an increasingly focused and robust product in the following years.

What RESTHeart actually does, in a minute

RESTHeart is a Java open source runtime for microservices. It leverages MongoDB to provide a instant persistence data API.

Instant REST API with MongoDB;
Built-in Authentication and Authorization;
Elegant Java and Kotlin Framework to extend the API.

RESTHeart is tailored for JVM, Docker and Kubernetes, designed to radically simplify server-side development and deployment.

Ready-to-run stateless Microservice;
Available as binary and Docker container;
Deploy both on Cloud and on-premises.

RESTHeart is a "low code" development platform: you can get most of the mandatory server-side functionalities usually required by any Web and Mobile application with just configuration.

RESTHeart allows to create REST Web Services in minutes: implement a simple Java interface and deploy the web service by copying its JAR file into the plugins directory.

@RegisterPlugin(name = "greeterService", 
    description = "sends a greetings message",
    defaultURI = "/greetings")
public class GreeterService implements JsonService {
    @Override
    public void handle(JsonRequest request, JsonResponse response) {
        if (request.isGet()) {
            var content = new JsonObject();
            content.addProperty("message", "Hello World!");
            response.setContent(content);
        } else {
            response.setStatusCode(400);
        }
    }
}

The main advantage with RESTHeart is that you can immediately write and read data into a MongoDB database using just HTTP. Your JSON will travel untouched from the client to the database and back.

Specifications

Written in Java 11
Built on top of RedHat’s Undertow non-blocking HTTP server.
Uses MongoDB and compatible databases for data persistence.
Fully stateless.
Can be packaged as a Docker container.
Can be easily deployed both on Cloud and on premises.

Main features

RESTHeart unlocks all the capabilities of MongoDB.
It can also connect to Mongo Atlas Cloud, Amazon DocumentDB, Microsoft Azure CosmosDB and Percona Server for MongoDB.

For a complete list of features please go to this page.

Try online

You can try a simple Angular Web application here.

Examples

This repository provides examples on how to extend RESTHeart with Java or Kotlin plugins:

Source code

The full source code is available on GitHub.