Edouard Dorier Portfolio

Building performant and scalable APIs is a common challenge across nearly all modern web projects. Historically, robust backend frameworks like Symfony (PHP) have dominated this space thanks to their maturity and solid architecture. But in recent years, solutions like Strapi — a headless CMS written in JavaScript — have shaken things up.

Often mistakenly seen as a simple no-code API generator with a graphical UI, Strapi is in fact a full-featured Node.js framework that allows for deep customization, complex business logic, and a modular architecture. And in a world where user experience is king, adopting a full JavaScript stack becomes a strategic advantage.

🧠 Strapi: Much More Than an Admin Interface

Strapi’s admin panel is certainly useful for managing data models, testing endpoints, or configuring user roles — but it’s only the starting point. Under the hood, everything is customizable.

Strapi lets you:

• Create custom controllers for advanced business logic
• Add reusable services to encapsulate complex behavior
• Intercept requests with custom middlewares
• Add hooks, lifecycles, or policies to modify database, auth, or permission behavior
• Expose REST or GraphQL APIs with a well-structured architecture

👉 In short, Strapi is a complete backend framework, but with a UX designed for productivity.

⚙️ Real-World Example: From Admin UI to Business Logic

Let’s take a common use case: a booking platform with timeslot management, dynamic availability, notifications, and multiple roles.

With Strapi, you can:

• Create relational data collections (users, timeslots, bookings)
• Add custom access policies based on roles and time conditions
• Write business services to handle booking conflicts and trigger emails or webhooks
• Use lifecycles to inject logic during creation or updates (e.g., block a slot when a booking is confirmed)
• Extend or override native endpoints with custom routes

🎯 The result: you can cleanly structure complex business logic while keeping the admin interface usable for content or operations teams.

🧩 A Modular and Maintainable System

Strapi follows a modular approach:

• Each feature can be isolated as a plugin (auth, uploads, email, custom logic)
• The project adheres to clear code conventions (MVC-style, with extendability)
• The architecture remains readable, even as the codebase grows

And because it’s headless, your backend can evolve independently from your frontend, which improves scalability and code clarity.

🌐 Fullstack JavaScript: Unifying Back and Front for Better UX

Choosing Strapi also means choosing a unified JavaScript stack: same language, same paradigm, same tooling.

Concrete benefits:

• Reduced friction between frontend and backend
• Shared business logic or types (especially with TypeScript)
• Smoother collaboration across teams
• Unified deployment and CI/CD (Node.js everywhere)
• More responsive UX design (API and frontend evolve in sync)

👉 For a user-centric approach, where fast iteration, functional consistency, and user experience are priorities, fullstack JavaScript offers an ideal playground.

⚖️ Final Comparison

Criteria	Symfony (PHP)	Strapi (Node.js)
Language	PHP	JavaScript (ES/TS)
API out-of-the-box	❌ (via API Platform)	✅ Native REST/GraphQL
Admin interface	❌	✅ Modern, customizable
Custom business logic	✅ (pure code)	✅ (controllers, services, lifecycles)
Modular architecture	✅	✅ Plugins, middlewares
Full JS stack	❌	✅
Front/back collaboration	Medium	Excellent
Ideal for rapid MVPs	❌	✅✅✅
Ideal for advanced logic	✅✅✅	✅✅✅

🧭 Conclusion: Strapi, the Experience-Oriented Backend Framework

Strapi isn’t just a CMS — it’s a powerful backend framework disguised as a user-friendly tool. It offers both the flexibility of custom code and the speed of a modern platform, all within a coherent JavaScript ecosystem.

Symfony remains a solid choice for complex architectures in PHP, but for user-driven projects with a strong frontend component, where experience design is just as important as backend structure, Strapi clearly has the edge.