
Fullstack Development
18 years of successive roles, each bringing its own stack. On Python (FastAPI, Flask), on modern TypeScript (Next.js, Prisma, Bun), on the JVM (Spring, Kotlin), and on PHP (Symfony, Magento, Joomla, Zend). Keep the posture of an operating CTO who codes, reviews, and arbitrates senior technical choices.
My definition
Fullstack development, the way I see it, is the language polyglossia required to ship a production SaaS: backend, frontend, scripting, and the ability to pick the right tool for each layer. I cover the PHP chain (Joomla, Zend, Symfony 2-7, Magento 1-2), the JVM (Java SE, Spring, Hibernate, Kotlin Android), and the modern TypeScript ecosystem (Node, Next.js 16, React 19, Prisma 7, Drizzle, Bun). It is the polyglot profile that lets a CTO step into the team's code. not to rewrite for them, but to defend code reviews, absorb load spikes, and arbitrate senior technical choices.
My current rhythm mixes daily code (ACCENSEO product lines, 234K solo lines on the accounting SaaS, OSS packages like tailwindcss-obfuscator) and monthly review (pair-programming with the apprentices, senior reviews on customer codebases). 31 technical references + 15 mobile in the portfolio (Top 3 frequency). Polyglossia is not an aesthetic goal: it is the consequence of 18 years of successive roles each carrying their own stack. Joomla 1.5 at ABDC, Zend Framework at Pluxnet, Magento 1.10 at Smile, Symfony 3-5 at Pichet, Next.js 16 at ACCENSEO.

The big 2026 shift is that the cost of writing code dropped with AI, not the cost of reading it. Stack Overflow analyses it in Why demand for code is infinite: How AI creates more developer jobs: with 80%+ adoption of AI coding tools among professional developers and roughly 51% daily use, the agent layer churns code at scale. but critical reading, system design, and architecture review have become the differentiator. The CTO who reviews a TypeScript + Prisma + Drizzle codebase in pair-programming with Claude Code ships faster than the one who delegates.
My evidence
Anecdote 1 : Shipping 234K lines solo on the ACCENSEO accounting SaaS
On the ACCENSEO accounting SaaS in 2025-2026, I was the only human developer facing a product no early-stage team usually ships alone: French accounting, taxation, banking (Open Banking PSD2), invoicing, 2026-2027 e-invoicing compliance, AI assistant. The cadence was unforgiving: if I dropped below 8K lines a month for 14 months, the product would not be ready before the e-invoicing deadline.
I ran a complete full-stack cycle every day: Next.js 16 + React 19 + TypeScript on the UI side, Prisma + PostgreSQL on the data side, Better Auth with MFA (email, TOTP, SMS), AI SDK for multi-provider orchestration (OpenAI, Claude, Gemini), Stripe for SaaS subscriptions, and a dedicated Node.js microservice for automated invoice retrieval. I personally handled the Open Banking PSD2 integration across 3 providers in parallel (GoCardless/Nordigen, Bridge, Qonto), the EDI Teledec submissions for VAT / IS / CFE / DAS2 / PAS, and a Chrome extension for automated form-filling on impots.gouv.fr. The pair-programming with Claude Code carried 80-85% of the implementation, but every file was reviewed, every tax computation validated by script, every feature put through non-regression tests.
234K lines shipped solo, 42 autonomous features, 382 API routes, 91 Prisma models, 6 differentiated roles, and the platform was running production-ready by the end of the cycle with 2026-2027 e-invoicing compliance reached ahead of the regulatory deadline.
What struck me on this project is that staying an operator as CTO changes everything: without the daily fullstack practice, I would never have framed a regulated domain in months. That posture - a CTO who still codes - is the one I want to keep on the next scale-up role, because it earns me the right to challenge senior technical decisions instead of delegating them.
Anecdote 2 : Publishing the OSS package tailwindcss-obfuscator
Late 2025 I needed a Tailwind v4 obfuscation tool for several ACCENSEO engagements, and the only existing alternative was broken. Rather than crafting a workaround per customer, I decided to turn it into an OSS product - because a well-built npm package costs less to maintain than a dozen custom patches. The window was tight: 6 weeks before the community fell back to hacks.
I set up a TurboRepo monorepo with pnpm workspaces to drive 25 internal modules, 5 bundler plugins (Vite, Webpack, Rollup, esbuild, Nuxt module) sharing the same core engine, and a Commander.js CLI for framework-less usage. The stack: TypeScript 5.7, Babel AST to parse JSX/TSX/Vue/Svelte/Astro/Qwik, PostCSS to transform compiled CSS, magic-string to preserve sourcemaps, Vitest for the 295 unit and e2e tests, and VitePress for the docs. Strict typing across the codebase, builds via tsup with full sourcemaps.
82K lines of TypeScript published to npm in 6 weeks, 10 frameworks supported, automatic detection of Tailwind v3 vs v4, first Tailwind v4-compatible tool on the market. Picked up by external teams within the first weeks, organic mentions in tech newsletters.
That package is what kept me sharp on modern TypeScript outside customer time. I have made it a rule to ship at least one OSS per year for the same reason: a CTO who stops publishing code eventually loses the daily reading reflex. And it is also a concrete credibility signal when I discuss a scale-up role - people ask for the OSS, not the resume.
Anecdote 3 : Full-stack Magento Enterprise refit at Fleurance Nature
On the Fleurance Nature refit in 2017, I came in as Senior Software Engineer full-stack at Smile on a Magento Enterprise Edition 1.10 platform: 60 accumulated custom modules, 1,040 modified PHP files, 3 stores (Fleurance Nature France, International, Mincifine) to refit simultaneously. The complexity came from both backend (EAV pricing matrix, 4 customer groups, bidirectional ERP) and frontend (mobile responsive, 3 distinct themes, internationalisation).
I owned backend through frontend without a hand-off: server-side PHP 5.3 + Zend Framework + Magento EE 1.10, MySQL with EAV, Varnish as reverse proxy, and the ElasticSearch backport on Magento 1.10 nobody had done before (autocomplete, faceted navigation, virtual categories). Front-side I produced the responsive wireframes (mobile, tablet, desktop), wrote the graphic specifications for the 3 themes, integrated the WordPress blog via RSS parsing (512 articles migrated lossless), and shipped the responsive front-end theme on the 3 stores. I documented the functional specs across 7 versions (from 30 to 50 pages) as the business cases unfolded.
Production rollout across 8 environments with zero major regression, the 58-day post-launch warranty handled in person, and the refitted platform held for more than 5 years in production without any further rewrite.
That assignment locked in a reflex I now replay: legacy PHP depth + modern stacks are not 2 separate worlds. Being able to read a Magento 1.x or Symfony 2 codebase today gives me access to CTO advisory audits that strictly modern-TypeScript profiles cannot run. It is exactly what let me chain Symfony 3-7 then the modern TypeScript stack with no breaks.
My self-critique
My levels per stack
- PHP (Joomla, Zend, Symfony 2-7, Magento 1-2): Expert, 16 years
- TypeScript / Node / Java (Spring, Hibernate): Senior
- Kotlin Android, Scala, Angular: Confirmed
Polyglossia is not an aesthetic goal but a consequence of the project: each role brought its stack, I keep practising it as long as it serves. What still needs strengthening: Bun + edge runtimes in production and Kotlin Multiplatform for cross-mobile.

Major differentiator versus CTOs who stopped coding. It is what gives me the right to challenge a senior technical decision, run a serious code review, and absorb a load spike. It is also what makes a solo-grade delivery cycle possible early-stage: the ACCENSEO accounting SaaS would not have been framed and shipped without this polyglossia.
Recent cadence indicator: 234K lines shipped solo in 14 months on the accounting SaaS (2025-2026), and 6 weeks to ship the first Tailwind v4-compatible obfuscator from scratch on Babel AST + PostCSS.
To myself: ship at least one OSS package per year to stay sharp outside the customer-comfort zone, never lose daily code reading even when the management load explodes.
To others: do not chase polyglossia for itself, pick a language per project, execute it fully, capitalise on the patterns. Writing discipline (automated tests, strict typing) matters more than the novelty of the stack.
My evolution in this skill
Fullstack development is what keeps my CTO scale-up posture credible on the engineering side. In the 24-month plan, it lets me pair-program with my teams, arbitrate senior code reviews, ship an MVP solo on a new market, and reinforce team cadence through reverse mentoring. Without it, the role tilts to a purely managerial posture and loses its operational lever.
The observable goal is to ship a complete MVP solo (back + front + infra) in under 6 weeks on a modern stack, and to co-author a referenced OSS package in the community. Practically: bring TypeScript / Node / Bun to Senior+, keep PHP at Expert, open Senior on Kotlin if mobile becomes relevant.
Daily code on ACCENSEO products (accounting SaaS, OSS packages), weekly pair-programming with alternants, monthly third-party codebase reviews (consulting audits). Master in Software Engineering active until 2026.

Possible Kotlin Multiplatform deep-dive if an ACCENSEO product requires cross-platform mobile. Total TypeScript (Matt Pocock) program planned 2026 to stabilize the Senior+ level. AWS Developer Associate certification considered 2027.
Systematic pair-programming with alternants as reverse mentoring (they bring modern reflexes, I bring architectural depth). Monthly reading of Effective TypeScript (Vanderkam), continuous follow of framework changelogs (Next.js, React, Prisma). At least 1 OSS package shipped per year as a discipline.












