GraphQL on a key-value database almost sounds like a provocation. On one side, the simplest data model imaginable: a key, a value, and that’s it. On the other, a typed query language usually associated with APIs exposing fairly deep object graphs. At first glance, these two worlds did not seem to have much to say to one another.

And yet, this is exactly what Materia KV now offers. You can continue writing data with any Redis or Valkey client and read it back through a GraphQL endpoint. No synchronization layer, no replica to maintain, no secondary datastore to feed. Everything you write on one side becomes immediately queryable on the other, within the same cluster. It’s the same database, seen through two different doors.

Materia keeps finding its way

Before going any further, let’s briefly revisit where Materia KV comes from, because the product was not built overnight. Since entering public Alpha, Clever Cloud’s serverless key-value database has steadily evolved based on your feedback. TTL support was quickly added to handle key expiration ; shortly afterward, KV Explorer was added to the Console, along with the clever kv command in Clever Tools, allowing you to browse your data without installing any third-party software.

JSON commands (JSON.GET, JSON.SET, JSON.DEL) came next, followed by the move to Beta with Hash support, the Set type earlier this year, and more recently a batch of new hash, string, and TTL commands. And let’s not forget that such an add-on can be deployed through both the provider Terraform and the Clever Kubernetes Operator.

The common thread running through this whole story remains the same: compatibility. We never wanted to force you into a proprietary API, an exotic ORM, or a Clever Cloud-branded client. You interact with Materia KV using protocols you already know. Redis/Valkey support came first. The GraphQL layer brings a new dimension.

How does it work in practice?

You write through the Redis API, read through GraphQL, and both interfaces operate on the same keyspace using the same token. The password used by your redis-cli ($KV_TOKEN, also available as $REDIS_PASSWORD, based on Eclipse Biscuit) also serves as the GraphQL bearer token. Existing add-ons therefore require no changes.

Because Materia KV is a distributed cluster, the endpoint is a single URL shared by all add-ons: https://materiakv-graphql.eu-fr-1.services.clever-cloud.com/graphql.

The schema exposes a single root type, MateriaKvQuery, covering strings, hashes, and sets. Open the URL in your browser and you’ll find a GraphiQL playground where you can explore the entire schema, or retrieve the SDL using the introspection tool of your choice.

One detail before we go any further: for now, this is read-only. No mutations. In many cases, that is sufficient. Writing remains the job of Redis and Valkey clients, which already do it perfectly well, while GraphQL focuses on querying data.

Time for some hands-on examples. Throughout the following examples, we write using redis-cli and read using curl, assuming the add-on environment variables have been loaded:

# On récupère les variables d'environnement de l'add-on, vous pouvez aussi le faire via un fichier .env par exemple
source <(clever addon env ADDON_ID -F shell)
export KV_GRAPHQL_URL="https://materiakv-graphql.eu-fr-1.services.clever-cloud.com/graphql"

First, a string. We create a key with redis-cli, then read it back through GraphQL:

redis-cli -h $KV_HOST -p $KV_PORT --tls SET demo:greeting "Hello, Materia!"

curl -s "$KV_GRAPHQL_URL" \
  -H "Authorization: Bearer $KV_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query":"query($key:String!){ string(key:$key){ key value } }","variables":{"key":"demo:greeting"}}'

Which returns:

{ "data": { "string": { "key": "demo:greeting", "value": "Hello, Materia!" } } }

What was written on one side is immediately readable on the other, with no delay and no intermediary layer. Where GraphQL starts to pull ahead, is when your data becomes more complex. Take a hash, for example, which carries a structured record:

redis-cli -h $KV_HOST -p $KV_PORT --tls \
 HSET demo:user:alice name Alice role admin email alice@example.com active true

GraphQL can return it as a typed list of { name, value } pairs, eliminating the need to manually parse a flat response on the client side:

query ReadUser($key: String!) {
  hash(key: $key) {
    key
    fields { name value }
  }
}

The same logic applies to a set, that collection of unique, unordered values that both protocols expose as a first-class object:

redis-cli -h $KV_HOST -p $KV_PORT --tls SADD demo:group:admins alice bob carol

It can then be queried using:

query ReadGroup($key: String!) {
  getSetMembers(key: $key) { key members }
}

Complex queries: where GraphQL shines

But here’s the part that, on its own, justifies the existence of this compatibility layer: GraphQL doesn’t just expose your sets, it knows how to combine them. Finding members present in two groups at the same time becomes a single query, without using SINTER, without precomputed indexes, and without performing the merge client-side.

redis-cli -h $KV_HOST -p $KV_PORT --tls SADD demo:group:admins alice bob carol
redis-cli -h $KV_HOST -p $KV_PORT --tls SADD demo:group:active alice carol dave

With keys = ["demo:group:admins", "demo:group:active"], you obtain: ["alice", "carol"]. The setUnion and setDifference fields follow the same principle: who is both admin and active, who is either one, who is an admin but not active. The computation remains on the cluster; only the result is returned:

query AdminsAndActive($keys: [String!]!) {
  setIntersection(keys: $keys)
}

TTL, seen from two angles

A detail for those who appreciate well-chosen formats. Redis thinks in relative TTLs, expressed in seconds; GraphQL, on the other hand, returns the absolute expiration timestamp through the expireAt field, typed as a DateTime scalar (RFC 3339). Two representations of the same truth, each in the unit that makes sense for its protocol.

redis-cli -h $KV_HOST -p $KV_PORT --tls SET demo:session:xyz auth-token-42 EX 300

The GraphQL query will then be:

query ReadSession($key: String!) {
  string(key: $key) { key value expireAt }
}

As for JSON documents, Materia KV stores them on top of strings while keeping Redis’ JSON API. GraphQL returns the serialized document as is: you parse it client-side, and every field makes the round trip without loss.

Test it end to end

To see the two layers working in concert, we have published an interactive demo, deployable on Clever Cloud, with the source code available on GitHub.

Written with Bun and its native APIs (Bun.serve, Bun.RedisClient), without any framework or superfluous library, it walks through six scenarios — string, hash, set, intersection, TTL, JSON. You click, and it shows you side by side the Redis commands being sent and the GraphQL query that reads the result back, with variables, raw responses, and response times.

Deploying it takes just a few commands:

git clone https://github.com/CleverCloud/kv-graphql-example
cd kv-graphql-example

clever create -t node -a kv-graphql-example
clever addon create kv kv-graphql-example --link kv-graphql-example 
clever env set KV_GRAPHQL_URL "https://materiakv-graphql.eu-fr-1.services.clever-cloud.com/graphql"

clever deploy
clever open

What’s next?

This first GraphQL implementation lets you test this approach and share your feedback with us. It is not an end in itself: mutations are among the options on the table, and as usual with Materia KV, your use cases will decide the order of priorities. So feel free to put it through its paces and tell us what you think is missing.

To dig deeper, everything is there: the GraphQL layer documentation, the changelog announcement, and the full example. And for those waiting to benefit from Materia’s resilience with clients from the DynamoDB ecosystem, this is underway through a dedicated product. It is currently being tested by customers using it for specific needs and will be opened more broadly a little later this year.

Over the past 15 years, we built Clever Cloud to avoid that trade-off, to offer a versatile European platform with managed services, on infrastructure we control, from partners or yours. Where your application always runs the way you designed it.

A complete platform, not a compute layer

What sets Clever Cloud apart is not any single feature — it is the breadth of what runs natively on the platform, managed by our team, on our infrastructure.

Deploy applications in 18 runtimes: Node.js, Bun, Python (with uv), Java (Gradle, Maven, WAR), PHP, FrankenPHP, Ruby, Go, Rust, .NET, Elixir, Scala, Haskell, V, Meteor.js, Docker, and two static runtimes — one based on Static Web Server/Caddy with automatic SSG detection (Hugo, Astro, Docusaurus, Zola, VitePress, Nuxt, MkDocs, mdBook, Storybook), the other on Apache with .htaccess support for SPAs and rewrite rules. If none of these fit, push a Dockerfile — full filesystem, TCP/UDP ports, multiple processes, your rules.

But compute is only the beginning. The platform includes managed PostgreSQL (versions 14–18, 40+ extensions, replicas, Pgpool-II), MySQL, MongoDB, Redis, Elastic Stack, and Materia KV — a serverless key-value store built on FoundationDB, replicated across three datacenters, with a Redis-compatible API. S3-compatible object storage with Cellar. Persistent filesystem with FS Buckets. Distributed pub/sub messaging with Apache Pulsar. An API gateway with Otoroshi. Identity management with Keycloak. Business intelligence with Metabase. Privacy-respecting analytics with Matomo. Git hosting with Heptapod. Transactional email with Mailpace. Easy ways to deploy preview applications from GitLab or GitHub.

Every database can be encrypted at rest with LUKS2/AES-XTS. Every service is provisioned as a managed add-on — one click, environment variables injected, integrated with your applications.

Co-built with open-source partners, integrated as managed services

Several of these services — Otoroshi, Keycloak, Metabase — are not just products we bundle. We co-build them with their respective communities, contribute, and operate them as fully managed offerings on our infrastructure. When we add a feature to Otoroshi or work on Keycloak's deployment model, that work benefits the open-source project and every Clever Cloud customer.

This approach extends beyond software. We are building an ecosystem of partners — resellers, system integrators, and technology partners — who bring domain expertise on top of the platform. Our academy trains teams to operate confidently on Clever Cloud, from onboarding to production. The goal is not to lock anyone in, but to create a network of people and organisations who know how to build well on European infrastructure.

Request flow: a programmable middleware chain

HTTP traffic on Clever Cloud does not go straight from the internet to your application. It passes through our Rust-based load balancer Sōzu and you can configure a chain of middleware — the Request Flow — that you control with a single environment variable.

Set CC_REQUEST_FLOW to compose a pipeline from built-in services: Varnish for HTTP caching, Redirection.io for URL rewrites and SEO-friendly redirects, OAuth2-Proxy for authentication, Otoroshi Challenge for request verification. Or plug in your own reverse proxy with CC_REQUEST_FLOW_CUSTOM, the platform handles port allocation automatically.

Need to cut public HTTP access entirely while keeping private networking alive? Set the flow to block. The platform returns a 200 OK to health checks while refusing all other traffic. Your application stays reachable through Network Groups, but invisible from the internet.

This is not a feature you find on most PaaS. Typically, you either get a fixed reverse proxy you cannot configure, or you set up your own Nginx/Caddy/HAProxy and manage it alongside your application. On Clever Cloud, the middleware layer is a first-class platform service.

Mise: one config file for tools, tasks, and environments

Every Clever Cloud runtime comes with Mise and can automatically add tools before the build phase. Drop a mise.toml at the root of your project, and Mise handles tool versions, environment variables, and build/run tasks declaratively.

This means you can install Deno on a Node.js runtime, get Bazel to build your project, pin a specific Hugo version on a Static runtime, or define build commands that work identically on your laptop and in production — without writing shell scripts or customising buildpacks. On the Linux runtime, Mise tasks are first-class: the platform checks for CC_BUILD_COMMAND/CC_RUN_COMMAND first, then Mise tasks, then Makefile targets.

Private networking with WireGuard and Tailscale

Network Groups create encrypted WireGuard overlay networks between your applications, add-ons, and external peers. Each member gets internal DNS resolution (<memberID>.m.<ngID>.cc-ng.cloud), all ports are accessible within the private network, and traffic never touches the public internet. Build microservice topologies where services communicate privately and only the API gateway faces the public.

For teams already using Tailscale, the integration is native: set TAILSCALE_AUTH_KEY and each application instance joins your Tailscale network as CC-<NAME>-<INSTANCE_NUMBER>. Use TAILSCALE_LOGIN_SERVER to point at a self-hosted Headscale control server. Accept DNS settings, advertise routes — it works the way you expect.

We also support IPSec and OpenVPN for environments that require them. Dedicated outgoing IP addresses are available for firewall whitelisting.

API first, AI ready

Clever Cloud is exposed as an API, built with Infrastructure-as-Code in minde. We built our own integrations on top of it. From the web Console to Terraform provider and major tools such as Kubernetes Operator, the Clever Tools CLI and its amazing AI Skills.

To ease AI usage, we provide LLMs.txt documentation summary, all pages are provided in Markdown format when requested by your favorite tools. Want to explore a deployed application ? clever ssh gives you a shell on your production instances, but you can also use clever ssh --command 'any command' and directly get the results. A great feature when you need Claude Code, Codex, Gemini or OpenCode to debug a running application.

Observability: Grafana, Warp 10, and custom metrics built in

Every service comes with a Grafana dashboard. CPU, RAM, disk, network, and requests per second are collected automatically. Pre-configured dashboards live in a "Clever Cloud" directory, and you can create your own, including alerts that notify you when consumption crosses a threshold.

Under the hood, metrics are stored in Warp 10, a geospatial time-series database with microsecond precision you can query with WarpScript — a stack-based language.

For custom instrumentation, push to StatsD on port 8125 or expose a Prometheus endpoint on localhost:9100. The platform collects over 170 Telegraf metric classes, all labelled with owner_id, app_id, host, and deployment_id. Blackfire profiling and New Relic integration are available for deeper application-level analysis.

Most platforms charge extra for observability, limit retention to hours or days, or require you to set up external tooling from day one. On Clever Cloud, logs are retained for 7 days with regex search, access logs come in multiple formats (CLF, JSON with geolocation and TLS version), and log drains forward to Syslog, Elasticsearch, Datadog, or New Relic without per-gigabyte surcharges.

Otoroshi: API gateway, WAF, and LLM gateway in one

Otoroshi is not just a reverse proxy. It is a managed API gateway that includes a Coraza WAF running OWASP Core Rule Set in WebAssembly — detection or prevention mode, custom rules per domain, audit logs for compliance. No "Enterprise tier required" caveat.

The LLM extension turns Otoroshi into a unified gateway for large language models, exposing an OpenAI-compatible API that routes multiple providers: OpenAI, Anthropic, Mistral, Cloud Temple, DeepSeek, Gemini, Groq, HuggingFace, Ollama, OVHcloud, Scaleway and others. Semantic caching reduces redundant calls. Quota management controls costs. Automatic failover switches providers transparently when one is down. Prompt fencing prevents sensitive information leakage. MCP (Model Context Protocol) support lets you build tool-using agents.

This runs as a managed service on your Clever Cloud account — no separate vendor, no per-token markup. It's the tool we chose to build the technology at the core of Clever AI.

Clever Tasks: run, pay, stop

Not every workload is a web server. Clever Tasks are applications that execute a command and shut down. Define any application as a Task, set CC_RUN_COMMAND="python manage.py migrate", trigger with git push or clever restart, and the scaler runs for exactly as long as the command takes. You pay for build and execution time, per second.

Use them for database migrations, test suites, file conversions, data processing, compilation jobs — anything that should not run on an always-on instance. Chain multiple commands with && or wrap them in a script. Every environment variable from your application is available.

This is fundamentally different from cron-based schedulers with 10-minute minimum intervals, 5-task limits, and "execution is expected but not guaranteed" disclaimers. A Clever Task runs when you tell it to, for as long as it needs to, and stops when it is done.

European infrastructure, real sovereignty

Clever Cloud runs on infrastructure we operate across many regions: Paris, Gravelines, Roubaix, London, Warsaw, Montreal, Singapore, and Sydney. We partner with European providers — OVHCloud, Scaleway — and do not depend on a single US hyperscaler. Our approach to sovereignty is structural: 100% French capital, European-only hosting, no exposure to extra-territorial legislation.

Several regions carry HDS certification (Hebergement de Données de Santé), the French regulatory standard for hosting health data. This applies to all managed databases in those regions — PostgreSQL, MySQL, MongoDB, Redis, Elastic Stack — not just a subset. It is not an add-on with a monthly surcharge; it is built into the infrastructure. For organisations requiring the highest level of qualification, we also offer SecNumCloud-grade options within our cloud offer.

Data stays in the region you choose. There is no "default to us-east-1" behaviour, no background replication to a jurisdiction you did not select, no fine print about processing data in another country for operational purposes.

Predictable pricing

Billing is per second, based on instance size and runtime duration. Not per invocation. Not per request. Not per edge cache hit. Not per million operations on a key-value store. Your monthly bill varies by roughly ±5%, because it tracks actual compute usage — not traffic spikes multiplied by unit rates you did not notice in the pricing page.

Log drains do not cost per gigabyte. Grafana dashboards and Warp 10 metrics are included. Databases backups are included. Observability is included. You do not need to budget for six line items just to see how your application is performing.

What we are building next

We know where the platform needs to grow and listen to market needs Clever Kubernetes Engine is our current development priority. But we also work on many new features and services. Feel free to tell us what you expect the most.

Cloudflare has just announced Vinext, a drop-in replacement for Next.js built on Vite. The project is vibecoded, experimental, but the promise is compelling: builds up to 4x faster, bundles 57% lighter, and 94% coverage of the Next.js API. We wanted to see how easy it would be to deploy it on Clever Cloud.

If you develop with Next.js, you know its strengths, but also its frustrations: sometimes slow builds, heavy bundles, and an ecosystem that can feel locked in. Vinext takes the approach of (almost) reimplementing everything — routing, server rendering, React Server Components, server actions, middleware — as a Vite plugin.

In practical terms, your existing Next.js code should work as-is. Your app/ and pages/ folders, your next.config.js: everything should be compatible. You just replace next with vinext in your scripts. While Cloudflare naturally highlights deployment on Workers, Vinext is not tied to their infrastructure. 95% of the code is pure Vite. The vinext start command launches a standard Node.js server, deployable anywhere. Including on our platform.

Deploying Vinext on Clever Cloud: as easy as it gets

There is no specific adaptation required. You simply need an application in a local Git repository, or a GitHub account linked to your Clever Cloud account, and push your code into a Node.js/Bun application. In our example, we used Bun, which is automatically detected and used.

So, if you have the Clever Tools and Git installed on your machine, all you need to do is:

# Clone the example repository 
git clone https://github.com/CleverCloud/vinext-example 
cd vinext-example

# Create the application, deploy it, open it in your browser
clever create -t node 
clever deploy 
clever open

That’s it. You get an application with a fully configured and up-to-date instance, a domain, and its SSL certificate already set up. Of course, you can easily change it and, with just a few settings, commands, or clicks in our Console, deploy this application in other countries through the infrastructures of our partners such as Ionos or OVHcloud, adjust the number or size of instances, and more.

An application created and deployed with AI

One of the goals of this project was also to see how far we could go by having a tool like Claude Code build and deploy this application by simply providing it with a few elements: the Vinext announcement blog post and the Node.js/Bun deployment documentation for Clever Cloud.

Overall, it went quite well. Between the initial prompt and the first production deployment of the application, only a few minutes passed.

Of course, not everything was perfect. Since Claude did not know Vinext, it initially added Next.js as a dependency to the project, and we had to ask it to remove it. We also suggested an optimization for running the build command, which it had triggered using the pre-run hook instead of post-build (right after downloading dependencies). We eventually defined it as a post-install script in the package.json. This change allows us to keep the full application in the build cache and therefore start a complete application, isolated in a virtual machine, in 15–20 seconds (30–40 seconds with the build).

For the rest, Claude Code read and analyzed the provided documentation, created the project, identified the correct Clever Tools options to create the application, and iterated on the demo page design based on our recommendations.

All of this happened in an interactive conversation where each choice could be discussed and adjusted. The AI proposes, the developer decides — it’s teamwork, made easier by the broad compatibility and speed of the Clever Cloud platform. Even part of this blog post was written that way. Can you guess which part?

Want to give it a try?

Even in version 0.0.5, the Vinext project looks promising. The build is fast, deployment works — now it’s time to challenge its Next.js compatibility to verify that it truly delivers, beyond the case of a simple application. The project is experimental, but it deserves close attention.

Deployment on Clever Cloud is immediate. One environment variable for the build, automatic Bun detection, and you’re in production. No Dockerfile, no CI/CD pipeline to configure. If your application listens on port 8080, it runs. You can even add Varnish cache, authentication, or other features via the Request Flow.

AI accelerates exploration. When facing a brand-new technology, having an assistant capable of reading documentation, writing code, and managing deployment in real time helps create proofs of concept (PoCs) and early iterations. We have put many initiatives in place to facilitate this, from our documentation automatically served in Markdown, with an LLMs.txt, a Skill, and a reference doc for the Clever Tools. Feel free to explore these possibilities and share your feedback with us — it will help us continue improving Clever Cloud and making developers’ lives easier, according to their needs.

The source code of the demonstration used in this project is available on GitHub. If you have any questions, our team is available to support you.

When you deploy a website or an API, on Clever Cloud or elsewhere, you sometimes need to add some “intelligence” upstream of your application: transformations on request contents or headers, authentication, security rules, or even simply exposing additional content.

This is where an API Gateway such as Otoroshi can be useful. And you should not limit it to this denomination: its capabilities are numerous and may help in many situations, well beyond topics directly related to APIs.

An open-source solution worth knowing (and supporting)

Otoroshi is an open-source project from MAIF that many customers had already been deploying on Clever Cloud. When we decided to create turnkey managed services such as Keycloak, Matomo or Metabase, Otoroshi quickly appeared as another solution that could make your life easier and to which we could add value through deeper integration within our platform.

We therefore decided to work with Mathieu Ancelin, one of the main Otoroshi developers and co-founder of Cloud APIM, to develop complementary solutions around this highly comprehensive API Gateway.

This has led to solutions such as Biscuit Studio, which enables simplified management and use of the tokens we rely on in our services and that form the foundation of our future IAM, now under the umbrella of the Eclipse Foundation. And also Clever AI, which aims to abstract and simplify the functionalities related to the use of AI models and their integration into enterprise needs.

But Otoroshi goes much further. Beyond its native features, it comes with numerous plugins, sometimes little-known even to experienced users. Let’s take a quick tour of those that may interest you, amuse you, or that have been recently added.

Deploying and managing Otoroshi has never been easier

Let’s start by creating an Otoroshi add-on, which can be done in just a few clicks from our Console. This deploys a Java application and a Redis database, both preconfigured. You do not need to do anything more: the dashboard displays the essential information such as your credentials for the web interface, the API, the link to the OpenAPI.json file, etc.

When a new version is available, you are notified and can update it with a single click. All of this is also possible through our API or Clever Tools, our CLI. These two tools also give you additional possibilities such as integrating your Otoroshi instance into a Network Group (more on this in a future blog post), customising the domain of its interface, or configuring new routes.

clever addon create otoroshi myOtoroshi \
  --option access-domain=otoroshi.example.com \
  --option routes-domain=otoroshi-routes.example.com

The only thing you will need to ensure is that the DNS of these domains correctly point to the servers of the Clever Cloud zone where Otoroshi is deployed.

Create your first route and… a static site

Once your Otoroshi instance is created, log into its web UI. You can then create a new route either via the “+” button at the top right of the interface or through the shortcut in the left-hand menu. You can define the name of the route, its description, etc., and then create it by clicking “Create Route” at the top right. You will then arrive in the designer.

It visually displays the route as configured, its frontend parameters (the exposed domain through which you access the route), and the backend to which it redirects. You can test the frontend URL (without port 80 and the /*), which by default returns a page showing the headers of the received request.

You can then search for a plugin to use and add it to this default route: "Force HTTPS traffic". Click “Add to flow” and then “Save”, and it will automatically redirect to a secure version of your pages (automatically handled on Clever Cloud).

You can then adjust a few details. For example, click on “Frontend” in the flow and append /static to the domain, then save the route. You must now use the URL https://your-domain.tld/static to access the backend.

Next, replace the backend with static HTML by adding the Static Response plugin. This plugin lets you always return the same HTML content on a route, which is useful for a “one-page app”. Insert the HTML of your choice into the “body” section of the plugin, for example:

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Otoroshi Static Route</title>
</head>
<body>
    <h1>Welcome to Clever Cloud</h1>
    <p>This page is hosted by an Otoroshi instance</p>
</body>
</html>

Save the route, and the static content will then be served at https://your-domain.tld/static.

What if your site were a Zip file?

This functionality exists in several forms in Otoroshi. You can serve static content from a folder on the instance, an S3-compatible object storage service such as Cellar, or… a zip archive.

To do this, remove the previous static plugin from the route and add "Zip file backend". Save the route. By default, this plugin contains the URL of a zip file leading to an older version of the Otoroshi documentation. When a request arrives, the archive is downloaded, decompressed, and then returned. It is cached according to the TTL setting (3,600,000 ms by default, one hour).

You can therefore store static sites in a service such as Cellar and host them on different routes or domains within the same Otoroshi instance effortlessly.

Send emails from your provider through a REST API

Another interesting feature of Otoroshi deployed on Clever Cloud: the "Mailer endpoint" plugin. It allows you to use any SMTP email-sending service—from your ISP to Gmail or Outlook, or a service hosted by Gandi or OVHCloud—and turn it into a REST API for sending emails.

To do this, create a new route ending with /email, for example. Add the plugin and provide the SMTP server parameters: host, username, password, etc. Once configured, save the route. You can then send emails using a simple cURL request:

curl -XPOST https://votre-domaine.tld/mail \
  -H 'Content-Type: application/json' \
  -d '{
    "subject": "Test Email",
    "from": "your name",
    "to": ["your-email@example.com"],
    "text": "This is a test email"
  }'

Be careful: as it stands, the route has no authentication. To add some, include the APIkeys module. You can then create an API key in the dedicated menu and assign it to your route via the “Authorized on” selector. Once done, you can send the same request but must include basic auth or the bearer token of your API key for Otoroshi to accept it.

Otoroshi supports many authentication solutions, such as JWT, Biscuit, and more complex ones such as Keycloak.

Otoroshictl, the CLI that makes life easier

What if you could perform all these actions with a single command? That is the promise of the Otoroshictl CLI, which allows you to manage your Otoroshi instances and recently gained a simplified mailer-plugin setup feature:

# You can also download binaries from GitHub
cargo install otoroshictl
otoroshictl toolbox add-mailer

The application will ask you for your SMTP parameters, create the route, the API key, configure everything, and provide a sample cURL request.

To do this, you must first configure your Clever Cloud Otoroshi instance as the one to use. Once again, Clever Tools makes this easy:

# Activez la gestion des opérateurs tels qu'Otoroshi
# Si ce n'est pas déjà fait
clever features enable operators

# Récupérez la configuration de votre Otoroshi
# Passez là à otoroshictl comme configuration courante
clever otoroshi get-config myOtoroshi | otoroshictl config import --stdin --current

This Rust application is open source (Apache 2.0 licence), so feel free to propose ideas or contribute.

Expose a Swagger UI from a simple openapi.json

Another feature that may interest those providing APIs that follow the OpenAPI standard: simplified hosting of a Swagger interface. Add the "Swagger UI" plugin to one of your routes, specify the path to your OpenAPI.json file, and a Swagger UI page will be generated with your preferred settings for sorting operations, tags, themes, etc.

llms.txt support: make life easier for AIs

Do you have online documentation? LLMs prefer to consume it in Markdown format. The llms.txt standard was designed for this, and static site generators such as Hugo are beginning to support such features natively.

But how do you return the Markdown version of a page when it exists? Many services, especially in the AI space, include the header: Accept: text/markdown in their requests to indicate their preference. Your web server must support this for it to work, which requires configuration.

Otoroshi now includes an "LLMs.txt Accept Markdown" plugin to address this need: if the header is present in a request and a Markdown version of the page exists, that version is returned. A caching system is also available to reduce response times. To use it, simply add it to a route, configure the cache duration and size, and save.

Want to know more? Come and see us at FOST (formerly apidays)

As you can imagine, we could talk for hours about Otoroshi and its features. One thing is certain: in its ocean of possibilities, there is surely something useful for you. Our advice: deploy one, test, experiment, and share your suggestions and feedback.

We will be present next week at FOST (formerly apidays) where we will host our Amazing Clever Cloud Enterprise Summit (ACCES) with our clients and partners to discuss what lies ahead for Clever Cloud in 2026. Feel free to come and meet us.

Discover Workflows at 13:00

You can also visit our Twitch and YouTube channels at 13:00. We will present Otoroshi live, along with its latest major features, including one added earlier this year and refined since then: workflows. They let you create full automation scenarios alongside your routes and their plugins, AI models with programmable management, or simply define them through a visual editor. Come and ask your questions live!

Somewhat paradoxically, the biggest change of the past few months is also the least visible from the outside: the strengthening of our “Clever Cloud Everywhere” approach.

An open cloud platform that adapts anywhere, to your needs

Because we are more than a PaaS provider with our own infrastructures,we offer our customers the ability to deploy their applications and services with our partners (Cloud Temple, Ionos, OVHcloud, Scaleway, etc.), or even on their own servers, for use cases ranging from edge deployments (local machines) to fully air-gapped environments (disconnected from the Internet).

So, you don’t have to adapt to the constraints of our cloud, the opposite is true. In 2025, a growing number of customers asked us for fine-grained adjustments to fit their needs, which we are always happy to provide. As a result, if you want your own Clever Cloud, that’s entirely possible: we can supply partner hardware or install our platform on infrastructure you already have. This is precisely how we operate outside of Paris.

Moreover, after opening a zone in London and establishing partnerships in West Africa and Kazakhstan, we have also announced our new Moroccan subsidiary. At the same time, we continue to strengthen our local presence, through our integration into the Fabrique IA Territoriale in Pays de la Loire, our support for startups via the UP Program, and our partnership with the German company SpiNNcloud to build a European computing platform for AI.

Kubernetes at Clever Cloud

Another major milestone reached by our teams is the launch of Clever Kubernetes Engine (CKE), our managed Kubernetes offering. It is currently available to a limited number of customers who are actively using it, and can already be accessed through our API, Clever Tools, and the Console. It will be opened more broadly in the coming weeks.

Two new points of presence in Paris

This expansion of our services goes hand in hand with an expansion of our infrastructure, as we move from 3 to 5 datacenters in the Paris region. We have begun our deployment both in Vélizy with our partner Etix and by strengthening our partnership with TeleHouse through a presence at TH3 (Magny).

This will enable us to meet our customers’ growing needs while preparing the introduction of new services, such as our forthcoming Infrastructure-as-a-Service (IaaS) offering, which you should hear more about next year.

Are you Clever Cloud certified?

2025 was also the year we launched our first certification program, which had been highly requested by several of our customers and partners. This first step was accompanied by the continued strengthening of our sales team over the past few months.

A second, intermediate-level course is arriving very soon. This will allow us to better support you on a daily basis and take the time to address your needs, while multiplying workshops and training sessions—both in person, via webinars and through live streams on YouTube and Twitch. Next step: Clever Cloud ambassadors!

Continuous improvement of our offering

Naturally, we have continued to improve our long-standing PaaS solution by releasing new images and features every week. Integration has become faster as well, with updates such as Node.js 24 and Java 25 now supported, along with improved compatibility for pnpm and Yarn alongside Bun. .NET 10 and PHP 8.5 are next in line.

We are also gradually shortening update cycles for several database services. As a result, PostgreSQL 18 is already available, and Redis 8.4 as well as Elasticsearch 9 are on the way.

In addition, we have kept strengthening the managed services we offer across the platform, including Keycloak, Matomo, Metabase, and Otoroshi. All of them are now available in their latest versions, with the ability to manage updates at creation time and from the Console dashboard, as well as to enable advanced features when needed.

Thus, we introduced Secure Multi Instances in Keycloak a few months ago, leveraging our Network Groups. These groups can also be enabled in a single click within the Otoroshi API Gateway to connect multiple applications. Otoroshi now also supports loading third-party plugins and configuring domains at creation time.

Other services continue to evolve as well. For example, Materia KV is now available in beta and will keep improving ahead of its planned general availability early next year. Similarly, Apache Pulsar will reach the same milestone soon, with updated pricing to accompany the release.

Our offering is also becoming increasingly accessible through a tool we significantly strengthened this year to support some of our customers’ needs: our provider Terraform. After reaching version 1.0 this summer, it is now available as version 1.7.1,providing a wide range of capabilities. Feel free to try it out and share your feedback and suggestions.

Clever Tools and Console evolve, the revolution in 2026

Clever Tools can now be executed via npx, support the new drains, and have gained numerous features over the past months. We began a major redesign with version 4.0, released last September. And this work will continue throughout 2026.

In the Console, we recently rolled out our new interface for access logs, with add-on logs coming next. We will progressively extend the new dashboards to all our services, then integrate Network Groups and introduce a native management interface for our object storage solution, Cellar.

But the most significant shift has been the deeper redesign of the Console itself. This work comes alongside new APIs aimed at modernising the platform and the services it provides, with the same goal as always: making developers’ lives easier.

Such progress are supported by foundational work carried out quietly throughout the year: the complete overhaul of our JavaScript client. Easier to use, more complete, type-safe, and managing API Tokens, it will serve as the basis for several upcoming initiatives we will announce soon.

Want to know more? Join us at ACCES!

As you can see, 2025 has been a year full of updates and significant changes for Clever Cloud and our team. And 2026 is set to follow the same trajectory. To see what’s coming next, feel free to join us at the Amazing Clever Cloud Enterprise Summit (ACCES) taking place on Thursday, 11 December 2025 during FOST (formerly apidays), which will take place from 9 to 11 December. We will host a pavilion with several of our clients and partners to showcase what we are preparing for the months ahead — from Clever IA to Materia TS to our KMS.

Deploying a PHP application is, as with any runtime, a breeze. It can be done from the Console, but also via the API or Clever Tools with a single command:

clever create -t php

PHP on Clever Cloud: full-featured, simple, straightforward

Add an index.php file to display the PHP configuration in a local git repository, and you won't need to do anything else to deploy. You prefer PHP 8.3 to 8.4? No problem, just configure an environment variable:

echo "<?php phpinfo();" > index.php
git init
git add index.php
git commit -m "Initial commit"

clever env set CC_PHP_VERSION 8.3
clever deploy

This will launch an application with PHP and Apache automatically configured, dependencies installed via Composer during the build phase, dozens of active or activatable extensions, the Symfony CLI, session management (which can be easily moved to Redis or Materia KV), the ability to enable Varnish caching just by adding a file to your repository, simplified configuration via an .ini or .htaccess file, and more.

Everything is detailed in our documentation (open source, feel free to contribute).

• Learn everything about PHP with Apache deployment on Clever Cloud

Redefining the user experience with FrankenPHP

But just like PHP, this runtime was getting old and needed to be overhauled. When we launched an in-depth review of our image management, creation process and the implementation of an entire automation and testing stack, we faced a dilemma: PHP is used by thousands of customers/applications in production, with PHP 5.x, 7.x and 8.x being managed up to the most recent versions. If we update our runtimes on a weekly basis, profound changes can quickly have major impacts that are difficult to anticipate. This limits our iteration speed and our innovation capacity.

So we set out to rethink things from scratch, with a brand new PHP experience on Clever Cloud that would gradually benefit our ‘Legacy’ deployment. FrankenPHP was the ideal candidate for this.

We discovered it at the end of 2023 and began testing its use within Clever Cloud. The project, which consists of combining an embedded PHP, a modern and easy-to-configure web server such as Caddy with a C ‘glue’, was gaining traction. Above all, it was developed by Kévin Dunglas from the Les Tilleuls cooperative, ‘ mates’ with whom we already had many friends and customers in common.

We therefore planned to integrate FrankenPHP gradually. First, to meet the needs of our first customers who requested it in early 2024, we posted a few ready-to-use examples on our GitHub account and provided some support for its deployment in Docker applications.

More importantly, this was the first of our new runtimes, launched at the beginning of the year. It was a winning bet, since a little over a year later, FrankenPHP became a project managed within the PHP Foundation. We now support several clients and partners in their use of FrankenPHP, including Les Tilleuls, who say: ‘We are delighted to join forces with Clever Cloud and FrankenPHP to push the boundaries of performance, simplify deployment and guarantee uncompromising reliability and security.’

Compared to traditional PHP runtime, our offering benefits from simpler but also more comprehensive deployment tools, which ultimately allow you to take any PHP project and deploy it in a Clever Cloud application with FrankenPHP without having to configure anything, not even a Dockerfile.

Deploy FrankenPHP as easy as 1-2-3 with Clever Cloud

Returning to our earlier example, we can delete the application we created and create a new one using the FrankenPHP runtime. It will be both similar and very different:

clever delete
clever create -t frankenphp
clever deploy

Similar because you benefit from the same simplicity and tools offered by Clever Cloud, with its logs, metrics and ease of configuration, which greatly contributes to the speed gains provided by our platform.

All this with unparalleled versatility, since you can deploy in our infrastructure, but also in that of our partners Ionos, OVHcloud, and Scaleway, in France and Europe or even on other continents. This can be managed with a single click in our Console, as can the activation of horizontal, vertical, or automatic scalability.

Different because we natively support FrankenPHP's Worker mode, its use for launching scripts (e.g. for Clever Tasks), listening port management, Caddyfile configuration, etc. Of course, we make it easy to use Redis or Materia KV, integrate dozens of extensions, Symfony CLI, use a local version of Composer or even Varnish.

But we do it in a new way, for example with the integration of Request Flow, which allows you to combine Varnish with tools such as Redirection.io or the reverse proxy of your choice, which also made its debut on these runtimes. If you simply want to test several of these features, we have a GitHub repository for that.

• Learn everything about FrankenPHP with deployment on Clever Cloud

Come and meet us to find out more

We will be on Thursday 17 September and Friday 18 September at the API Platform Conference, where we will present the work we have been doing over the last few months on our images and FrankenPHP, as well as our plans for future developments and new features.

We will also be present at the PHP Forum on 9 and 10 October alongside AFUP, which we sponsor throughout the year, to celebrate the association's 25th anniversary and 30 years of PHP.

In the meantime, feel free to try FrankenPHP on Clever Cloud and share your ideas, opinions and needs with us. We have an open discussion on this topic within our GitHub community.

Since its launch, Bun has gained reliability and features. As version 1.3 approaches rapidly, this solution stands out for:

• Strong performance thanks to its development in Zig
• An all-in-one approach: runtime, package manager, bundler and test runner
• Integrated tools: Shell script management, native clients for PostgreSQL, Redis or object storage services such as Cellar
• Good compatibility level with the existing Node.js ecosystem

Evolution of support on Clever Cloud

Two years ago, we explained how to deploy an application with Bun on Clever Cloud. The flexibility of our platform already allowed exploiting it both as a runtime and a package manager, with few configuration and environment variables.

Since then, we have observed a growing demand from our clients for native Bun support, whether for testing or migrating their production. As part of the overhaul of our images and runtimes, we have simplified its deployment process.

Enhancements made

We have integrated several changes in the Node.js runtime deployment, progressively renamed "Node.js & Bun" in our interfaces and documentation (the type remains node in the API and Clever Tools for compatibility reasons).

Thus, if CC_NODE_BUILD_TOOL=bun, Bun will be used automatically as runtime and package manager within your project. If it has a bun.lock file at its root, this won't be necessary: Bun will be detected and activated by default (use the bun install --lockfile-only command if the bun.lock file doesn't exist).

Of course, we maintain all our configuration flexibility and you can override this behavior by modifying CC_NODE_BUILD_TOOL to specify the tool of your choice.

• Node.js & Bun runtime documentation

How to deploy in practice

Want to simply test this functionality? Go to the Console then:

1. Create a "Node.js & Bun" application on Clever Cloud
2. Follow the instructions, deploy your project
3. Magic happens automatically!

Advanced method: with Clever Tools

You can also follow the instructions below with Clever Tools (you'll need git and Bun on your system):

# Project creation
mkdir bunDemo && cd bunDemo
git init

# Project initialization with Bun and React
bun init --yes --react
git add . && git commit -m "Initial commit"

# Clever Cloud Deployment
clever create --type node
clever deploy
clever open  # Open your deployed application in the browser

What you get

Your React application will leverage Bun as runtime and for dependency management, with the complete Clever Cloud experience:

• Real-time logs for debugging
• Integrated performance metrics
• Domain with automatic HTTPS access
• Automatic redeployment if there are any issues
• Auto-scaling capability based on traffic

All without ever having to configure a single server.

Why choose Bun on Clever Cloud?

The Bun + Clever Cloud combination offers you:

• Optimal performance: ultra-fast runtime + European infrastructure
• Deployment simplicity: from your local code to production in a few clicks
• Complete ecosystem: database, object storage, managed services, monitoring

Start today

Ready to discover the power of Bun on European cloud infrastructure? Take advantage of our €20 credits offered to test this solution without commitment. Whether you want to migrate an existing project or start new development, Clever Cloud facilitates your Bun adoption.

• Create your free account and test Bun

Need help? Our support is available to assist you in your migration to Bun. For larger projects, feel free to contact our sales team.

While attendees enjoyed our live demonstrations proving that these new features were more than just announcements, we have continued to improve our platform ever since. What has changed in practice? Here's an overview.

Two new zones, Paris certified HDS

The first big change, awaited by many customers, was our HDS certification for the infrastructure we have in Paris (parhds). It complements our ISO 27001:2022 certification, and enables us to better serve customers requiring a secure, sovereign offering, with the simplicity of Platform-as-a-Service (PaaS).

• Clever Cloud's health data hosting (HDS) offering

Although not always visible from the outside, the opening of new zones has been a major focus for several of our teams in recent months, whether it be our expansion in France, the opening of the London zone (ldn) on Ionos infrastructure, or even the setting up of private zones or “air gap” for dedicated customers. Indeed, one of the key promises of Clever Cloud is its versatility: we deploy wherever you need us.

A new process for our images, full of new features

We've been working for almost a year on a major overhaul of our images, the way we build them, test them and make them available to you. With one key objective: to increase the pace of updates and to multiply the number of enhancements.

This has been a gradual process over the months, and it's now complete: every Clever Cloud runtime is integrated into this fully automated process. It has already enabled us to deliver simplified version management for Node.js and Varnish, support for Docker Buildx, a faster git clone, Java 24, native support for Bun (JavaScript) and uv (Python) for your deployments.

We've also added Request Flow, a feature that lets you easily configure services such as Redirection.io, Varnish, or a reverse proxy of your choice, with automatic port management.

Four new runtimes

It's also this image overhaul that enables us to provide FrankenPHP, Linux, Static and V runtimes. The first is the fruit of discussions with our friends at the Les Tilleuls cooperative, co-founded by Kévin Dunglas, who also created FrankenPHP.

When we first saw the project, we were impressed by the ease of use of this tool and the possibilities it unlocks for the PHP ecosystem. We wanted to be one of the first Cloud Service Providers to offer it to our customers. It's done: deploying a PHP application on FrankenPHP requires no effort and very little adaptation. Give it a try and let us know what you think.

Linux runtime lets you deploy any kind of application on Clever Cloud, with the help of the Mise package manager which is now in all our images. Static is an overhaul of our static site hosting offering, with greater flexibility, lighter, more modern web servers, and automatic build via generators such as Astro, Docusaurus, Hugo, mdBook, Mkdocs, Nuxt.js, Vitepress or Zola. V, as its name suggests, lets you exploit the possibilities of V language and its native web server.

• Learn more about FrankenPHP runtime
• Learn more about Linux runtime
• Learn more about Static runtime
• Learn more about V runtime

The Console and Clever Tools at your service

Our work over the last few months has not simply involved extending the Clever Cloud offering, but also making it easier to use through our various integrations and interfaces. For example, we've updated our JavaScript client, our Rust SDK, added support for products in the Clever Kubernetes Operator or our Terraform provider.

The Clever Cloud Console now offers a better interface for managing OAuth Consumers, OAuth tokens and web sessions. We've also added tips on how to use various features with Clever Tools or the API via cURL, which you can display with just one click and then use directly.

This focus to ease your use of Clever Cloud was also behind the 3.13 release of Clever Tools, where many commands have been revised with this in mind. They also include features for direct management of your account e-mails, SSH keys and managed services such as Keycloak, Matomo, Metabase or Otoroshi, which you can now update with a simple command.

Generate API Tokens

Clever Tools and Console have shared the implementation of another major feature: the creation and management of API Tokens. They allow you to use our public API with a simple bearer token without the need for an OAuth Consumer/Token.

This will greatly simplify your own Clever Cloud integrations, scripts and other CIs.

• Learn more about API Tokens

Many more improvements to discover…

But that's not all, and the list of new features added to Clever Cloud in recent months is extensive, from support for Redis 8 with the JSON module active by default, PostgreSQL 17, now used as the default version, Matomo 5.3, Metabase 55, the use of PHP 8. 4 by default, the availability of Clever Tools via WinGet on Windows, the activation in Otoroshi of the Biscuit Studio, API and workflow functionalities, cost and ecological impact analysis in the LLM extension, with support for audio and image models, simplified linking of API management information to your applications.

As we announced in March, Network Groups are now in production and available to all. They enable you to create a secure link between your applications, add-ons and your own machines, using the Wireguard protocol. We're continuing to improve this functionality and extend it across our services.

• Learn more bout Network Groups

… and more to come

What's next? A few days ago, we passed a significant milestone concerning our managed Kubernetes offering using Materia Etcd, developed with one of our customers and whose opening to more users is being prepared over the summer.

We've spent the last few months fine-tuning Clever AI to make it easier for you to use AI models, particularly in a teamwork, enterprise context, with monitoring, management and high-availability needs. Presented at Vivatech, it will also open up to a growing number of customers this summer and then starting in September.

We'll be continuing with our secrets management solution (KMS), Materia Time Series (TS) based on Warp10, a major milestone for our Redis® compatible distributed Key-Value solution (Materia KV), and our Function-as-a-Service (Faas).

Clever Cloud, a cloud like no other

All this hard work has not prevented us from defending our values, our vision of a sovereign, comprehensive and easy-to-use European cloud, whether at Micode, in government ministries, by supporting startups or through our participation in collaborative projects such as CollabNext. We also announced a strategic partnership with Grist, Octopize, simplified Docs deployment, worked with Kazakhstan and QazCloud as we did last year for Clever Cloud Africa.

Want to find out more about our products and actions? Follow our live demonstrations on YouTube, our podcast Message à caractère informatique (MACI), our Shorts, our demos and open source projects, or even our webinars such as the one on our Managed Keycloak offering, with secure multi-instances (via Network Groups).

In short, if you thought the last six months had profoundly changed (your way of seeing) Clever Cloud… wait until you see whats coming next…

PostgreSQL 16 and 17 available, with their extensions

As we did with our runtime updates, we needed to rethink and improve the processes to support a new version within our managed database offering (DBaaS), enabling us to be more responsive. To achieve this, we first had to deal with issues relating to the maintenance of old versions and their dependencies, which were blocking us on a regular basis.

Then, we laid the groundwork for the future. Over the last few months, we have not only prepared our platform for PostgreSQL 16.8 and 17.4, but also for all the extensions we integrate or provide on-demand.

Only a few are no longer supported: plcoffee, plls, plv8 from PostgreSQL 16 and pgadmin from PostgreSQL 17.

• PostgreSQL 16 and 17 release notes

Migrate in a single click

We've integrated this into our migration process. To migrate from a previous version of PosgreSQL to 16 or 17 on Clever Cloud, simply go to the add-on's migration tool within the Console, choose the targeted version (the region and/or plan if you wish to change it as you go), wait a few minutes depending on the size of your database, which will be placed in read-only mode during the operation, and you're done.

If an incompatible extension is used, the process will fail and your database will remain in its initial state.

Next steps

To prepare for the future, we announced that it will no longer be possible to deploy end-of-life versions of PostgreSQL (11 and 12) as of April 30. Existing databases will of course remain in place, but we encourage customers to update them as no new functionality or security patches are added.

Over the next few months, we'll be finalizing the tooling that will enable us to make PostgreSQL database extensions configurable, with the objective of delivering this feature with version 18, scheduled for release in November.

This will enable us to offer it in a basic version initially, then allow you to activate extensions on-demand as and when they are updated and available for this new version.

• PostgreSQL versioning policy

More than just a service provider, Clever Cloud is at the heart of an ecosystem that brings together different initiatives. The fest was an opportunity to look back on the transformation that has taken place over the last few years, to talk about a number of products and to make some important announcements that reinforce its position as a leader in the secure, sovereign Cloud.

These announcements were made on Thursday 6 February at 2:00 PM during a keynote session accessible via social networks and live streaming platforms.

You can watch all the Clever Cloud Fest content live and in replay on YouTube and LinkedIn.

Thursday 6 February 2025

YouTube

LinkedIn

Friday 7 February 2025

YouTube

LinkedIn

New PaaS Initiative: towards a faster, ever more secure platform

Three years ago, Clever Cloud began to reinvent itself. Under the impetus of the new management team, which has gradually expanded, the company has taken advantage of its continued growth to expand its teams, building on its two historical strengths: technological excellence and security by design.

It has strengthened its strategic independence, and now has its own infrastructure in three Paris data centres, in addition to the deployment zones it offers in France and around the world with its partners.

It has successfully obtained ISO 9001, ISO 27001:2022 and, more recently, HDS certification for hosting healthcare data. Clever Cloud is thus reinforcing its position as leader in PaaS in Europe for public authorities, businesses and major accounts.

2025 will be the year in which Clever Cloud implements its plan for a new PaaS. Faster, more complete and easier to use, whether you're a developer, a solopreneur or a group of teams, the new Clever Cloud will meet your needs even better.

The broad outlines of this project will be unveiled by CTO Steven Le Roux during a presentation. It will be rolled out throughout the year.

Clever AI: adapting AI to business needs

Clever Cloud has announced the launch of Clever AI, a new range of products designed to adapt the integration of artificial intelligence to business constraints. It is multi-vendor, multi-model, and adds control and functionality to all the solutions on the market. Clever AI can be used in serverless mode, in dedicated instances or on-premises.

Based on the Otoroshi open source API Gateway, and developed in collaboration with Cloud APIM, Clever AI represents a major evolution in Clever Cloud's service offering. It is positioned as a complete platform enabling companies to aggregate numerous LLMs (Large Language Models), to create a connection with an IAM tool and also to set up usage rules, blocking certain keywords in prompts, for example, and thus preventing the disclosure of confidential information. In practical terms, Clever AI aims to enable AI to be used securely and in line with business requirements.

This solution offers :

• Compatibility with numerous AI providers, including OpenAI, Anthropic, Azure, DeepSeek, Gemini, Groq, x.AI, as well as European services such as Hugging Face, Lucie, Mistral, OVHcloud and Scaleway;
• Advanced features such as authentication, caching, logging, model selection and customisation, access to a personalised chat interface and Model Context Protocol (MCP) support;
• An administrator interface accessible via Console, API or CLI, making it easy for development teams to use and integrate with third-party tools;
• The ability to create custom prompt rules. This feature enables companies to effectively prevent the leakage of sensitive data when using AI models, and so define restrictions on the type of information that AI can process or generate, as well as customising AI interactions so that they comply with internal security policies;
• Integrated compliance and usage analysis tools to provide the traceability that the company needs to ensure the high level of monitoring required, but also to continue to ensure a certification policy.

‘With Clever AI, we offer our customers a sovereign, out-of-the-box solution for integrating AI into their business processes,’ says Quentin Adam, CEO of Clever Cloud. ‘Our platform enables businesses to quickly reap the benefits of AI while maintaining control over their data and processes.’

Clever AI is available in private alpha and for testing by Clever Cloud customers, marking an important step in the company's strategy to democratise access to AI technologies for businesses of all sizes. You can apply for early access before it goes public in a few weeks' time.

Clever Cloud unveils its FaaS

Clever Cloud is introducing its Function-as-a-Service (FaaS) solution, enabling developers to deploy and run individual functions without managing the underlying infrastructure, based on the Web Assembly Standard (WASM).

The exclusive WSR (Wasm Svm Runtime) technology is the result of several years' work by the Clever Cloud teams, who have developed a set of solutions for instant execution, as close as possible to the hardware layer, while remaining easy to use and open to various languages/runtimes.

What is FaaS?

Clever Functions is based on an event-driven architecture. Developers write functions that are triggered by specific events, such as :

• HTTP requests;
• Database modifications;
• Messages in a queue.

These functions are then deployed on a Cloud platform that automatically manages the allocation of the necessary resources.

The benefits of FaaS

FaaS brings cost benefits, allowing you to pay only for the time the function is used, and makes it easier to implement microservices. It can be used in a simplified way with all Clever Cloud solutions, including Clever AI.

Clever Functions is currently in private alpha. You can request early access before its gradual opening to all our customers.

Clever Cloud now offers a Kubernetes solution

Clever Cloud has its own orchestrator, designed to provide automated, optimised management of Cloud applications. At the same time, Kubernetes has established itself as a market standard that can be complex to implement at scale.

To meet our customers' expectations, we developed our own Kubernetes solution, with specific features to simplify long-term operational maintenance, incorporating Clever Cloud's expertise and DNA. To achieve this, our teams have developed a specific, compatible database that overcomes the major shortcomings of the Etcd component at the heart of Kubernetes deployments.

This technological approach means we can better meet our customers' needs, in terms of quality of service, functionality and scalability.

Kubernetes vs. the Clever Cloud orchestrator: a different approach

Kubernetes is an open-source container orchestrator that automates the deployment, scaling and management of containerised applications.

Historically, Clever Cloud has been a software developer for the Cloud, and then became a hosting provider. The strength of our solution lies in the creation of a virtual machine (VM) orchestrator that enables a modular, automated and scalable architecture to be created, with very few adaptations required during application development.

The advantage of this solution is that each machine is partitioned, unlike container-based operation where isolation is not total. As part of the market is using Kubernetes, it was natural for us to respond to this demand. So we're now offering our customers a managed and hardened Kubernetes solution, offering the same level of security and fluid experience as our orchestrator.

A Kubernetes approach from Clever Cloud

Unlike traditional Kubernetes implementations, our solution integrates natively with the Clever Cloud ecosystem. This means:

• Simplified configuration optimised to meet customers' core needs ;
• Seamless integration with other Clever Cloud services, including our CI/CD, database management and security tools;
• Tailored scalability, leveraging our experience in automated infrastructure management.

‘We've always seen Kubernetes as a technology that can become complex to manage over the long term if not properly imagined and managed. But we also know that it has become an unavoidable market standard. So our approach has been to rethink Kubernetes to integrate it with our philosophy: make the infrastructure invisible so that developers can concentrate on what they do best, develop.’ Quentin Adam, CEO of Clever Cloud.

Conceived as part of the CollabNext project, this Kubernetes solution is available as a private alpha and will be deployed to a growing number of customers over the course of 2025. You can request early access before it is gradually rolled out to all our customers.

The Materia range is expanding

Materia: a serverless, distributed database

In 2024, Clever Cloud announced the launch of Materia: a set of distributed, serverless data storage solutions designed for interoperability, automatically adapting to the amount of data being processed, from zero to infinity.

Replicated in our three Paris data centres, it ensures high availability and maximum resilience. Based on the same technological foundation as Apple CloudKit and Snowflake, it is compatible with many existing protocols, making it easy to integrate into applications.

The first version to be presented to the public was Materia KV, a key-value database. Today, Clever Cloud is proud to announce Materia KV JSON and Materia TS.

Materia KV JSON: simplified access to JSON data

Materia KV JSON allows you to store and access JSON objects in a single command, enabling you to make direct queries on the keys/values it contains.

The commands in this feature are compatible with the Redis® protocol and can therefore be used with any client in this ecosystem, including Valkey. Support for Materia KV JSON is part of the Materia experience, and comes at no extra cost.

Why Materia KV JSON?

• Storage and manipulation of JSON data directly in applications hosted on Clever Cloud or other service providers, without lock-in;
• A resilient solution by design thanks to its replication. When Materia KV responds, your data has been written three times;
• Simple to use, thanks to its serverless approach, access is instantaneous and there is direct integration with the Clever Cloud environment.

Materia KV JSON allows developers to manage structured objects without complexity. This functionality is currently in private alpha access. You can request early access before it is gradually made available to all our customers.

Materia TS: storage and analysis of time series

With Materia TS, Clever Cloud introduces a Time Series data management engine, based on Warp10, designed for applications requiring efficient analysis of events over a given period.

Main use cases

• Monitoring and observability: storage and querying of logs, metrics and events.
• Financial analysis: monitoring market fluctuations and transactional data.
• IoT and sensors: management of data flows generated by connected objects.

Materia TS provides storage adapted to the reading and analysis of time-stamped data, facilitating queries and the visualisation of trends.

Materia TS is deployed for certain customers. You can request early access before Materia TS is gradually rolled out to all our customers.

Clever KMS: Manage and secure your secrets

The new KMS service offers an advanced password and secret management tool. Developed specifically to meet the needs of an institutional customer, this solution enables secrets and encryption keys to be managed, and is designed to protect sensitive data while remaining simple to use.

Integration with existing ecosystems is at the heart of its design. Clever KMS can be used with any tool compatible with the Vault client (Hashicorp). This is what enabled us to integrate easily with Otoroshi.

Fonctionnalités principales

• Secure storage of secrets, API keys and certificates;
• Native encryption to protect data in transit and at rest;
• Integration with Clever Cloud applications, without complex configuration.

With KMS, Clever Cloud meets the growing need for security and compliance, while simplifying the management of secrets for developers. It can be deployed in serverless mode, in dedicated instances or on-premises.

Clever KMS is deployed for certain customers. You can request early access before it is gradually rolled out to all our customers.

Clever Cloud and Otoroshi: new features for more secure and flexible API management

Clever Cloud today announced the integration of new features into its Otoroshi-based API Gateway-as-Service offering, making API management more secure and flexible for businesses.

Otoroshi is an open-source solution created by Mathieu Ancelin, co-founder of Cloud APIM, that makes it easier to manage, secure and monitor APIs and microservices. It offers authentication mechanisms (OAuth2, OpenID Connect, Biscuit, JWT), as well as fine-grained access management via API Keys and quotas.

Its routing engine enables load balancing, failover and the application of advanced rules such as circuit breakers. Finally, it protects services against various attacks (DDoS, brute force, injections) and provides real-time monitoring tools.

Advanced security features and simplified access management

Otoroshi instances deployed on Clever Cloud now include:

• Biscuit support, with a complete Biscuit Studio suite for generating, verifying, mitigating and managing the roles of these secure tokens, enabling decentralised verification integrated with your APIs and services;
• Simplified configuration of the Coraza Web Application Firewall (WAF). This mechanism strengthens security by filtering malicious requests and blocking intrusion attempts before they reach backend systems;
• Simplified configuration of routes, API tokens and access protection for Clever Cloud applications, in conjunction with Network Groups;
• Native Clever KMS integration for secrets management.

‘API management offers a whole range of potential services to be developed. We'll be unveiling them over time.’ explains Steven Le Roux, CTO.

Otoroshi is now available on Clever Cloud with its LLM extension, Biscuit Studio and support for Clever KMS. Simplified integrations are undergoing public testing and will be rolled out later this year, along with a serveress offering.

Keycloak-as-a-Service: a secure multi-instance offering

The complete identity and access management solution has been available since last year, developed in conjunction with Please Open IT. Clever Cloud is proud to announce the availability of its secure multi-instance mode, an exclusive feature made possible by the creation of Network Groups. Keycloak can now be deployed in the form of a cluster within Clever Cloud, with communication between instances taking place via a Network Group, our secure network based on Wireguard. Everything is automatic.

Designed to meet the most stringent security and compliance requirements, Keycloak offers advanced services such as single sign-on (SSO), automatic scalability and centralised identity management.

Key features of Keycloak-as-a-Service include:

• Seamless integration with existing applications;
• Easy creation and import of realms;
• Advanced authentication and authorisation features (OAuth 2.0, LDAP, SAML, OpenID Connect, etc.);
• Automatic scalability to suit all user volumes;
• Compliance with the most stringent security and confidentiality standards;
• Ongoing maintenance, offering a simplified managed solution.

‘With Keycloak-as-a-Service, we're making identity management considerably simpler for our customers,’ says Quentin Adam, CEO of Clever Cloud. ‘This solution enables businesses of all sizes to benefit from a high-level IAM, without the usual complexity of implementation and maintenance, all for a price that we wanted to be particularly attractive.’

Keycloak on Clever Cloud has just been upgraded to version 26.1.0 and will be available in its final version shortly, benefiting from all the work carried out by our teams and Please Open It during the beta phase. To find out more about the benefits of Keycloak-as-a-Service, a full demo is available for replay on Clever Cloud's YouTube channel here.

Network Group: a step forward in network management

Clever Cloud makes it possible to deploy applications and services that are independent of each other, but which may also need to communicate via dedicated channels. Some customers have also asked us to be able to access their services within a secure network from third-party instances or from their machine.

This is how we came up with Network Groups, based on Wireguard technology and compatible with this market standard.

Network Groups bring greater flexibility to the management of network environments. This solution makes it easier to segment and secure inter-application communications on Clever Cloud. It also enables Keycloak to be deployed in multi-instance mode, or to control access to applications when used in conjunction with Otoroshi, demonstrating the potential synergies between our products.

Network Groups are part of a drive to improve the user experience by simplifying network configuration while offering advanced options for the specific needs of each customer. This feature marks an important step towards a more modular and secure infrastructure.

Network Groups are available to all our customers in public beta and will be enhanced with new integrations and features over the coming months.

Databases : Even more advanced management

The Managed Databases product range, which provides access to a database (PostgreSQL, MySQL, MongoDB, Elastic, Redis®/Valkey, etc.), has also been enhanced.

Already equipped with a range of advanced features, such as automatic backups and on-demand configuration to suit requirements, the products in the database range now come with the ability to manage extensions automatically, enabling us to upgrade versions more quickly. Versions 16 and 17 of PostgreSQL are now available on Clever Cloud.

Our Elasticsearch and PostgreSQL offerings can be enhanced with extensions to order or after the fact, while benefiting from automatic migrations, with continuity of service for extensions too.

This feature enables us to adjust a set of extensions per database, and therefore per customer. The aim is to enable us to be more responsive while continuing to meet the sometimes specific needs of certain customers.

Clever Cloud unveils its Hypervisor-as-a-Service project

A few months ago, Clever Cloud announced a partnership with Vates, a French specialist in open source hypervisor solutions, to work on the creation of an on-demand Xen hypervisor solution for managing virtual machines (VMs). Today, we are proud to be able to present the first public demonstration of this project.

A response to companies' expectations in the face of market challenges

Since Broadcom's acquisition of VMware, the virtualisation ecosystem has been going through a period of uncertainty. The sharp rise in prices, the withdrawal of certain traditional offerings and the increasing technological lock-in have prompted many businesses to look for alternative, more open and independent solutions.

But beyond this context, demand for Hypervisor-as-a-Service (HaaS) solutions is growing, particularly for open source solutions. Companies want to take back control of their technological destiny by migrating to more sovereign solutions, without having to manage the complexity of maintaining them in operational condition.

The first bricks

In practical terms, this means that Clever Cloud is able to :

• Show an initial demonstration of how the Xen hypervisor works;
• Present usage scenarios and gather feedback from the first testers before opening up the service more widely;
• Refine the technical set-up to ensure a smooth, accessible experience. This demonstration validates the principles of virtualisation tailored to the needs of businesses that want to retain control over their infrastructure, without the constraints imposed by a single supplier.

A more complete and resilient Cloud

This announcement is part of Clever Cloud's commitment to providing the most comprehensive offering possible, combining IaaS, PaaS and turnkey services, to support businesses in all their infrastructure needs.

‘The announcement of our partnership with Vates generated a great deal of interest, and we're delighted to be able to demonstrate the first concrete applications. This project is part of our drive to offer a more open and sovereign infrastructure. We want to offer businesses a reliable and economically viable alternative that gives them back control of their infrastructures without imposing dependency,’ says Quentin Adam, CEO of Clever Cloud.

This project continues to evolve, with adjustments and optimisations based on user feedback, before being made more widely available in the coming months.

Azimutt, Mailpace, Metabase: numerous tools, a single platform

2024 was an opportunity for Clever Cloud to strengthen its Marketplace offering. Facilitated by its turnkey add-on providers solution, it enables any customer to create solutions that can be deployed on Clever Cloud within their account and their organisations.

But we are working with a number of partners to extend this availability to all our customers. As we have done with Keycloak and Otoroshi, we have opened up access to our platform to Mailpace and Metabase as well as Azimutt.

Azimutt is a member of our Up! start-up support programme, and we are working to simplify its integration into our platform. The service is now focused on analysing and understanding databases, with alert management, to complement our managed database offering.

Deployed via a Clever Cloud gateway for our customers, Azimutt is available as a free version or via paid subscriptions directly within our platform.

Over the course of 2025, we will be strengthening these partnerships, as well as taking advantage of the synergies between these services, as we are already doing with Mailpace and Metabase, or Keycloak and Otoroshi, which are used within Clever AI.

FrankenPHP, mise, Redirection.io, uv: responding to change

As ecosystems evolve, so do the needs of developers. Over the last few years we've seen far-reaching changes in application tooling, whether through the proliferation of JavaScript runtimes, or the arrival of solutions that are turning usage on its head, such as the uv package manager for Python or FrankenPHP.

Clever Cloud has chosen to embrace these transformations by natively integrating these tools, whose use will be simplified from the first months of the year. You can already use the meta packager, uv, shown in our latest images, to manage your Python applications and packages, while FrankenPHP will be available in the form of a dedicated runtime.

This modern PHP server is designed to improve the performance and flexibility of PHP applications. It has been developed by Kevin Dunglas, known for his work on API Platform and his involvement in the PHP and Symfony ecosystems.

What sets FrankenPHP apart from other PHP servers such as Apache + mod_php, Nginx + PHP-FPM or Caddy, is that it relies on Go and Caddy to offer more efficient execution and simpler configuration. In particular, it enables:

• Native execution of PHP applications without the need for PHP-FPM;
• Advanced management of workers and scalability;
• Improved integration with modern technologies, such as WebSockets and asynchronous workers.

FrankenPHP aims to simplify the deployment of PHP applications while optimising their performance, in particular by reducing latency and improving response time. Clever Cloud has decided to integrate FrankenPHP to offer PHP developers a more powerful and easy-to-use environment. With this support, Clever Cloud users will be able to simply run their PHP applications directly on FrankenPHP, benefiting from its optimisations and ease of management.

But the tools don't stop at putting applications into production. We are also gradually integrating solutions from partners such as Redirection.io to make it easier for our customers to use them in production, with the integration of their subscription-based offering.

Demonstrations of these different solutions will be held throughout Clever Cloud fest.

Clever Cloud Africa: a strategic partnership for a sovereign Cloud in West Africa

Clever Cloud and DataConnect, a subsidiary of New Digital Africa (NDA), are joining forces to co-build the first stage of a secure, sovereign Cloud in Côte d'Ivoire. This collaboration between Clever Cloud, a French creator of deployment and hosting solutions in PaaS (Platform-as-a-Service) mode, and the leading African provider of managed infrastructure services, marks an important step in the development of an autonomous digital ecosystem in West Africa. Already widely acclaimed by the Ivorian press, the actual launch of Clever Cloud Africa will take place in the second quarter of 2025.

This joint initiative, based on a shared vision between the two companies, aims to combine Clever Cloud's technological expertise with DataConnect's in-depth knowledge of African markets. The aim is to co-develop innovative Cloud solutions that meet the specific needs of businesses and public authorities in the region.

The partnership is based on several areas of collaboration:

• The co-creation of sovereign Cloud solutions tailored to local needs;
• Developing and training local IT talent;
• Strengthening the regional technology ecosystem;
• Supporting the digital transformation of organisations.

Quentin Adam, CEO of Clever Cloud, underlines the collaborative dimension of the project: ‘Through this partnership, our ambition is to contribute with our local partners to the emergence of talent and value in the regions. Côte d'Ivoire was an obvious choice for us to co-construct a sustainable value proposition for companies and public-sector players looking to build their strategic autonomy in West Africa.’

Cette collaboration, initiée en Côte d'Ivoire, a vocation à s'étendre progressivement à d'autres pays d'Afrique de l'Ouest et Centrale, en s'appuyant sur des partenariats locaux dans chaque territoire.

Le Clever Cloud Fest était l’occasion d’annoncer officiellement ce partenariat, en présence de Jean-Jacques N’Docho, Directeur Général Adjoint de NDA Group, qui a fait le déplacement depuis la Côte d'Ivoire.

Jeudi 6 février, en amont du Clever Cloud Fest, un petit-déjeuner dédié à l’international, organisé par la région des Pays de la Loire, fut l’occasion d’échanges entre la délégation ivoirienne et élus et chefs d’entreprises locaux.