We challenged developers at Devoxx Belgium to build and deploy a real application, with a real database, in roughly 15 minutes. We gave them a little help from AI, a Belgian twist, and some LEGO as motivation. Here's what happened.

I've been attending Devoxx Belgium for almost 20 years. It's one of those conferences that means a lot to me, both personally and professionally. It's where I got the inspiration to create what would eventually become FinistDevs, where I started imagining myself as a conference speaker, and where, a few years later, I discovered that Developer Relations could actually be a job.

So when Clever Cloud decided to sponsor Devoxx Belgium this year, I was particularly happy.

But there was one question I wanted to answer before arriving in Antwerp: what could we do at our booth that would be genuinely interesting for developers?

Of course, we wanted people to discover Clever Cloud. That's why companies sponsor developer conferences in the first place.

But I didn't want to spend three days telling people how easy it is to deploy an application on our platform.

I wanted them to experience it.

And that's how the 15-minute Clever Cloud Challenge was born.

Stop Prompting. Start Shipping.

The idea was pretty simple.

Come to our booth. Open your laptop. Build a tiny application. Connect it to a real database. Deploy everything on Clever Cloud.

And do it in roughly 15 minutes.

There were only a few rules:

• Any stack. JavaScript, Python, Java, Go, whatever you prefer.
• Any AI. Claude, ChatGPT, Gemini, Copilot, or your favorite coding agent. We didn't care.
• A little Belgian flavor. Fries, beer, comics, cycling, Magritte, Devoxx itself. Anything vaguely connected to Belgium.
• A real database and a real deployment. Not a mockup, not a screenshot, not an application running only on your laptop. Something publicly accessible, with data that actually persists.

And because 15 minutes is a target, not a reason to punish someone for spending a little longer debugging, we weren't particularly strict about the stopwatch.

The important thing was to ship something.

We prepared a dedicated challenge page with instructions, a starter prompt people could copy into their favorite AI assistant, and a coupon giving them €200 in Clever Cloud credits, valid for six months.

The prompt suggested three small application ideas, helped the participant choose one, and guided them through development, database creation, and deployment.

We also added a little incentive: everyone who successfully completed the challenge could enter a daily LEGO draw. Because, well, LEGO.

But there was no jury, no ranking, and no prize for the most sophisticated application. A tiny, functional app had exactly the same chance of winning as an ambitious one.

We weren't organizing a hackathon, we were inviting developers to discover a platform by actually using it.

40 developers. 48 deployed applications.

And it worked.

Over the three days, 40 developers created and deployed an application with a real database on Clever Cloud.

I want to insist on that number for a moment.

Not 40 people who scanned a QR code, not 40 email addresses collected at a booth, not 40 coupons handed out.

40 developers who actually built something, provisioned a database, deployed their application, and came back to show us what they had shipped.

For me, that's a much more interesting result than the number of people who walked past our booth.

And the best part? What they built.

We deliberately kept the challenge open-ended. We didn't provide a template application or a predefined tutorial that everybody had to follow.

We gave people a goal, a few constraints, and the freedom to be creative.

The results were far more varied than I expected.

Some of my favorite applications

I couldn't possibly feature all 48 applications here, but I wanted to share a few that particularly caught my attention.

Not necessarily because they were the most technically sophisticated, but because they were fun, original, or made particularly good use of the challenge's constraints.

It's Raining Devs: Magritte meets Devoxx

Try It's Raining Devs

This one is probably among my favorites.

Take René Magritte's surrealist paintings, add a crowd of developers attending Devoxx, and turn the whole thing into an interactive, collaborative artwork.

Participants can create their own floating developer, choose what hides their face, give themselves a name, and join the painting.

And those developers aren't just temporary elements rendered in a browser. Each one is stored as a record in PostgreSQL on Clever Cloud.

There are even little interactions, a roll call, and postcards you can save or share.

I love this one because it combines something very Belgian, a genuinely playful idea, and a database that is an integral part of the experience.

It also illustrates something I really appreciate about these coding challenges: a tiny application doesn't have to be a boring application.

Roll for Waffle: let the dice decide your destiny

Roll your own Belgian waffle

What happens when you combine Belgian waffles with polyhedral dice, the kind you would normally use in a tabletop role-playing game?

You get Roll for Waffle, and I absolutely love it.

The concept is wonderfully simple: instead of choosing your waffle ingredients, you let the dice decide.

First, roll for your waffle base. Then roll for your primary topping. And finally, roll for a secondary topping. Each roll comes with a lovely animated polyhedral die, and the result is added to your creation.

Will you end up with a classic Liège waffle covered in speculoos spread and fresh strawberries? Or some completely improbable combination that no Belgian pastry chef would ever dare to serve?

That's the beauty of it. You don't get to choose. The dice have spoken.

And once your creation is complete, you can share your randomly generated masterpiece.

As someone who has spent a ridiculous number of hours rolling polyhedral dice over the years, this one immediately made me smile.

It's a perfect example of what I loved about the challenge: give developers a simple theme, a little freedom, and the opportunity to experiment, and they'll come up with ideas you would never have imagined yourself.

Now, if you'll excuse me, I have a waffle to roll.

Devoxx Bingo: because every conference has its clichés

Play Devoxx Bingo

If you've attended enough developer conferences, you know that some things are almost guaranteed to happen.

Certain expressions will be repeated. Certain technologies will be mentioned. Certain conference moments will feel strangely familiar.

Why not turn that into a bingo game?

Devoxx Bingo gives you a card of conference clichés to spot during the event. Mark them as you encounter them, and try to complete a row.

It's presented as an unofficial side quest, with absolutely no prizes and some very questionable bragging rights.

Exactly the kind of application that makes me smile.

And honestly, I can imagine people actually using it during a conference.

Devoxx YouTube Search: rediscovering conference talks

Explore Devoxx YouTube Search

Devoxx has an incredible collection of recorded conference talks on YouTube, accumulated over many years.

And as someone who has been attending Devoxx for almost two decades, I love the idea of making that knowledge easier to explore.

That's the idea behind Devoxx YouTube Search, another application created during our challenge.

What I particularly appreciate is the choice of subject. While many participants went for something playful or distinctly Belgian, this developer chose to build something directly connected to the conference and its content.

It's a lovely reminder that a challenge like ours doesn't have to produce just games and experiments. It can also inspire tools that address real needs within the developer community.

BelgiQ: how Belgian are you, really?

Try BelgiQ

BelgiQ describes itself as « Le quiz qui a la frite ».

That's already a good start.

It's a Belgian-themed quiz, available in French, Dutch, and English, with a leaderboard.

But what makes this application particularly interesting is that its creator, Gwenaël Jakab, shared his experience on LinkedIn.

Gwenaël decided to build BelgiQ using Node.js, Express and PostgreSQL. He used ChatGPT to prepare his prompt, then handed implementation and deployment to ChatGPT Work.

15 minutes later, he had a working application. After another 10 minutes of reviewing the result, making adjustments and requesting some refactoring, he had a V2 he was happy with.

And he hadn't written the application code himself.

What I particularly appreciated about his post was his perspective on the developer's role. Even when an AI agent handles implementation, someone still needs to make architectural decisions, define requirements, review the code and validate the result.

That's an important distinction, and one that sometimes gets lost in discussions about AI-assisted development.

For me, his experience also illustrates exactly what we were hoping to achieve with the challenge: let developers focus on what they want to build, while discovering how straightforward it can be to deploy it on Clever Cloud.

And the best part? You can try BelgiQ yourself.

Friesdvisor: the important questions in life

Explore Friesdvisor

Forget restaurant recommendations.

We're in Belgium. We need to talk about fries.

Friesdvisor is a directory where you can search for a friterie or a town and add new places.

It's a wonderfully straightforward idea, and exactly the kind of Belgian connection we were hoping people would invent.

I particularly like that it's not just a joke. It's a concept that could grow into a genuinely useful little community application.

And, of course, it needs somewhere to store all those friteries.

48 applications, and plenty more creativity to discover

These are just a few of my personal favorites.

But one of the things I loved most about the challenge was the sheer variety of ideas. Give 40 developers the same starting point, the same constraints, and roughly 15 minutes, and you get 48 different interpretations of what a tiny application can be.

Some went for games. Others built practical tools. Some embraced Belgian culture, while others found inspiration in the conference itself.

And I couldn't possibly do justice to all of them in a single blog post.

That's why we created the Built at Devoxx Belgium gallery, where you can explore the applications that participants chose to share publicly.

👉 Explore the Clever Cloud Challenge Gallery

Have a look around. Try the applications. See what people came up with.

And if one of them makes you smile, or gives you an idea for something you'd like to build yourself, then I think our little experiment has already achieved something pretty cool.

What did we learn?

A few things stood out to me during those three days.

First, developers are remarkably creative when you give them just enough constraints.

The Belgian theme was deliberately vague. We didn't want people spending ten minutes wondering whether their idea qualified.

A Belgian dish? Great.

A reference to a Belgian artist? Perfect.

A joke about Devoxx? Absolutely.

That small creative constraint gave people somewhere to start without telling them exactly what to build.

Second, AI coding assistants make this kind of exercise much more accessible.

Not everybody arrived with a project idea, a favorite framework, or a clear understanding of how to provision and connect a database. But with a little guidance, they could go from an idea to something running online surprisingly quickly.

Gwenaël's experience with BelgiQ illustrates another important point: AI-assisted development doesn't remove the developer from the process. It changes what the developer spends their time doing.

The developer still makes decisions, defines requirements, reviews the results, and takes responsibility for what gets shipped. Meanwhile, the coding agent can handle much of the implementation work, and the platform takes care of the infrastructure.

Of course, the AI didn't magically eliminate every problem. There were still deployment questions, configuration issues, and moments when someone needed a little help. That's why we were there.

But the combination of AI-assisted development and a platform that takes care of the infrastructure made it possible to focus on the interesting part: building and shipping the application. And that's exactly what we wanted people to experience with Clever Cloud.

Finally, I was reminded of something fundamental about Developer Relations.

Showing people how something works is useful. Helping them discover it for themselves is even better.

I could have spent fifteen minutes explaining how Clever Cloud handles deployments, databases, environment variables, and application hosting. Instead, developers spent those fifteen minutes doing it. And at the end, they had something of their own to show.

That's a very different conversation to have at a conference booth.

What's next?

The challenge doesn't have to end at Devoxx.

Everyone who participated received €200 in Clever Cloud credits, valid for six months after activation. That gives them the opportunity to keep experimenting, improve their application, or start something completely different.

We're also thinking about how to extend the experience with additional small challenges, encouraging participants to explore more of the platform.

And I'd really like to repeat this experiment at other conferences.

The Belgian theme worked beautifully at Devoxx Belgium. Imagine what developers could come up with at conferences in other cities or countries.

We already have a few ideas.

Your turn. Stop prompting. Start shipping!

I've attended a lot of developer conferences over the years, on both sides of the booth. I've distributed stickers, handed out T-shirts, given demonstrations, answered technical questions, and had countless conversations about cloud platforms. I still love all of that.

But watching someone arrive at our booth with nothing more than an idea, then return a little later with a working application deployed on Clever Cloud? That was particularly satisfying.

And seeing the creativity of those 40 developers made the whole experiment worthwhile.

So, to everyone who participated in the challenge at Devoxx Belgium: thank you!

Thank you for taking the time to try Clever Cloud, for embracing the slightly ridiculous Belgian theme, and especially for showing us what you built.

Want to give it a try?

Good news: you don't need to attend Devoxx to take the challenge!

The original Devoxx Belgium Challenge is still online, and we've also created a generic version of Stop Prompting. Start Shipping. that anyone can try, anywhere.

The special €200 Devoxx coupon is no longer available, but every new Clever Cloud account comes with €20 in free credits, which is more than enough to build and deploy a small application with a database.

Pick a theme. Open your favorite AI coding assistant. Give yourself 15 minutes.

Build something fun, connect a database, and deploy it.

And if you do, I'd genuinely love to see what you come up with. Share your application with me!

Stop prompting. Start shipping.

For years, developers have been using the platform, experimenting with it, deploying real projects, and then sharing their experience — through conference talks, blog posts, demos, meetups, and countless informal discussions. The Clever Cloud Ambassadors program is our way of recognizing and supporting this existing dynamic, while creating a clearer and more durable connection between the community and our teams.

This program is not about creating advocates from scratch. It is about supporting people who already care.

Why an Ambassadors Program?

Many developers already talk about Clever Cloud in their own words, in their own contexts:
presenting real-world use cases, building demos for meetups, writing articles or documentation, helping others get started.

Until now, these relationships existed informally. The Ambassadors program is a way to formalize this collaboration without changing its nature: no scripts, no obligations, no marketing pressure.

Our goal is simple: strengthen the link between Clever Cloud and its community, make it easier for developers to share their work, and ensure feedback flows both ways.

What Is the Clever Cloud Ambassadors Program?

The Clever Cloud Ambassadors program brings together developers who:

• actively use Clever Cloud,
• enjoy sharing technical knowledge,
• and contribute to developer communities.

The program is inspired by initiatives like Google Developer Experts, Microsoft MVPs, or GitLab Heroes — but adapted to Clever Cloud’s culture: small, technical, and human-sized.

Ambassadors benefit from:

• direct exchanges with Clever Cloud’s tech, product, and DevRel teams,
• platform credits to build demos and experiment freely,
• free access to Clever Cloud certifications,
• swag and community recognition,
• and support when speaking at conferences or meetups.

In return, we simply ask ambassadors to keep doing what they already do: build, share, and give honest feedback.

How the Program Works

The program is organized in annual cohorts.

Participation is voluntary and non-contractual. There are no quotas, no KPIs, and no required messaging. Ambassadors contribute in ways that fit their interests and availability: talks, articles, demos, workshops, or community support.

Just as important, the program is a two-way street: ambassadors help spread real-world knowledge of Clever Cloud, Clever Cloud listens, learns, and improves based on their feedback.

Authenticity matters more than reach.

Introducing the First Cohort

We deliberately chose to start small.

For this first iteration, we invited a limited number of community members to form a pilot cohort. Some immediately accepted, some declined out of humility (“I love Clever Cloud, but I don’t use it enough”), and others are still considering.

This response already reflects the kind of culture we want to build: honest, thoughtful, and grounded in real usage.

This first cohort will help us validate the format, refine the program, and shape how it evolves over time.

Meet the Clever Cloud Ambassadors

We are proud to introduce the first Clever Cloud Ambassadors.

Each of them brings a different background, set of skills, and perspective — from backend and frontend development to DevOps, cloud-native architectures, and community building.

Mathieu Ancelin

David Caussinus

Ludovic Piot

Sébastien Prunier

Mathieu Santostefano

Matthieu Vincent

Over the coming weeks, we will publish a short interview with each ambassador. These posts will give them the opportunity to share their background, how they use Clever Cloud, what they like to build, and why community involvement matters to them.

A Program Designed to Evolve

This program is intentionally iterative.

Over the coming months, we will experiment with formats and rhythms, listen closely to ambassador feedback, adjust benefits and interactions, and improve how the program supports both ambassadors and the broader community.

We prefer doing this right rather than doing it big.

Opening the program more widely may come later, but only once we are confident that it remains meaningful and authentic.

Want to Get Involved?

At this stage, the Clever Cloud Ambassadors program is invite-only.

That said, the best way to become an ambassador has always been the same: build things with Clever Cloud, share your experience, participate in the community, and engage with others.

We are always paying attention.

If you are curious, want to follow the program, or simply want to share what you are building, feel free to reach out or join our community spaces.

What is DevRel?

Developer Relations (DevRel) is about building bridges between tech companies and developers. The goal is to help developers better understand, use, and get the most out of the tools available to them, while also ensuring that companies improve their products through real user feedback.

DevRel typically involves several key activities:

• Content creation – blog posts, documentation, tutorials, and technical guides.
• Community engagement – participating in events, meetups, forums, and online discussions.
• Developer support – answering questions, providing guidance, and sharing best practices.
• Product feedback – relaying insights from developers to internal teams for continuous improvement.

At Clever Cloud, we take a different approach to DevRel: instead of making it the responsibility of just one team, we believe it should be a company-wide effort.

DevRel and Clever Cloud

Developer Relations (DevRel) is more than a role or department at Clever Cloud—it’s a philosophy embedded in how we engage with developers. We believe that helping developers is the best way to improve the ecosystem, and we take a unique approach: DevRel is not the responsibility of a single team, but rather a shared effort across the company.

In this post, we’ll explore why DevRel matters to us, our guiding philosophy, why we support developer communities, and how every Clever Cloud employee is encouraged to contribute to DevRel in their own way.

Why DevRel Matters to Clever Cloud

Clever Cloud exists to help developers deploy and run their applications without friction. But great technology alone isn’t enough—we need to ensure that developers can understand, adopt, and make the most of what we build. That’s where DevRel comes in.

DevRel helps us:

• Bridge the gap between engineering and developers: We turn technical expertise into accessible knowledge.
• Improve our platform: Direct interactions with developers provide valuable feedback.
• Strengthen our ecosystem: Engaging with communities helps build long-term trust and advocacy.
• Ensure developers succeed: Their success is our success, and DevRel helps them navigate the challenges they face.

Our DevRel Philosophy

At Clever Cloud, our approach to DevRel is shaped by a few core principles:

1. Honest, Useful Content

We don’t do marketing-driven, hype-filled DevRel. Instead, we focus on useful, technical content that genuinely helps developers—whether or not they use our platform.

2. Helping First, Selling Later

Our goal is to support developers without pushing our product. We write blog posts, contribute to open-source projects, and share knowledge because we believe in giving back to the community. The more we help, the more developers trust us, and some will naturally become Clever Cloud users.

3. Community-Driven, Not Self-Centered

We don’t try to own the conversation. Instead, we engage where developers already are—meetups, conferences, online forums—and participate as peers, not promoters.

4. Learning and Teaching

DevRel isn’t just about broadcasting knowledge; it’s also about listening and learning. Engaging with developers helps us improve our platform and understand real-world challenges better.

Why We Support Developer Communities

We believe that strong developer communities make the entire industry better. By sharing knowledge, supporting events, and contributing to open source, we help create an environment where developers thrive.

Here’s why it matters:

• Developers need spaces to learn and grow: Community-driven learning is powerful.
• Open knowledge benefits everyone: The more we share, the better tools and best practices become.
• Long-term trust beats short-term gains: By supporting developers, we build lasting relationships rather than chasing quick wins.

DevRel as a Shared Responsibility

At Clever Cloud, DevRel isn’t just for the DevRel team—it’s something every employee can (and should) be part of, regardless of their main role. We encourage and support everyone to contribute in ways that fit their expertise and comfort level.

How Non-DevRel Roles Contribute:

• Engineers write technical blog posts about the challenges they solve.
• Support and sales teams share insights from customer interactions.
• Product teams participate in community discussions and gather feedback.
• Everyone engages with developers on social media, conferences, and forums.

By distributing DevRel across the company, we get more diverse voices, authentic perspectives, and deeper technical expertise in our developer engagement.

How We Make It Work

To encourage company-wide DevRel participation, we:

• Support employees in writing and speaking by providing guidance and mentoring.
• Make time for contributions so DevRel isn’t just “extra work.”
• Provide internal platforms for knowledge-sharing (like internal tech talks and documentation improvements).
• Encourage open-source contributions as a way of engaging with developers.

Conclusion

At Clever Cloud, Developer Relations is more than a job title—it’s a shared effort to help developers succeed. By making DevRel a company-wide initiative, we amplify our impact, ensure authenticity, and build stronger connections with the developer community.

We’d love to hear from you! Whether it’s through blog posts, meetups, conferences, or open-source discussions, let’s keep the conversation going. Follow our blog, join us at events, and connect with us online.