Career background
I have been building software professionally since 2013. I started in the PHP era, first with WooCommerce and then deeper into Laravel, custom backends, admin dashboards, payment flows, and data-heavy business systems. That period gave me the kind of foundation I still rely on today: understanding how products break in production, how businesses actually use software, and why clear architecture matters more than flashy code. In those early years, I worked on real estate platforms, eCommerce systems, multilingual websites, internal dashboards, and custom business tools where the work was not just about making things look good, but about making sure they stayed reliable when real users, real data, and real money started flowing through them.
Over time, the kind of systems I wanted to build changed. Products became more interactive, frontends became more complex, APIs became more central, and mobile apps started needing the same level of quality and structure as web apps. At the same time, teams needed faster iteration, stronger typing, better component reuse, cleaner backend contracts, and more scalable ways to grow a codebase without rewriting it every few months. That is what gradually pushed me away from staying only in PHP/Laravel and into the JavaScript and TypeScript ecosystem.
I did not shift because Laravel or PHP are bad tools. I shifted because the kinds of products I wanted to build were better served by a more modern, end-to-end stack. React and Next.js gave me better control over complex frontend systems, product UX, performance, and reusable UI architecture. Node.js and NestJS gave me a cleaner path for APIs, background jobs, integrations, and shared logic across products. TypeScript made the whole system safer and easier to maintain, especially when frontend and backend needed to evolve together. Instead of treating the frontend as one world and the backend as another, I started building products where both sides could move together with clearer contracts and less friction.
Then Python became important for a different reason. As soon as data pipelines, automation, AI workflows, and LLM-based products entered the picture, Python became the right tool for parts of the system that were heavier on data processing, retrieval, AI orchestration, and long-running workflows. FastAPI especially made sense because it gave me a fast, clean way to expose Python services without turning them into a mess. So my stack evolved naturally: React and Next.js for product surfaces, Node.js and NestJS for app backends and integrations, Python and FastAPI for AI-heavy or data-heavy workloads, and Flutter where mobile mattered. It was never about chasing trends. It was about using the best tool for the problem while keeping the whole product coherent.
That same logic is what pulled me into Solidity and Ethereum. Once you start building serious payment systems, escrow flows, trust-minimized products, programmable money logic, and operator-controlled financial workflows, you eventually run into problems that are better solved onchain. Solidity was not a random add-on for me. It was an extension of the same work I was already doing around payments, trust, compliance, settlement, and product logic. Ethereum let me work with systems where money movement, approvals, milestone release, token operations, and smart account flows could be encoded directly into the product. I was not interested in hype or collectible-only projects. I was interested in products where onchain logic actually changes how the system behaves and what users can trust.
Along the way, I also worked beyond freelancing. I served as a remote CTO for a European startup, which gave me a much deeper understanding of how products are actually delivered at the business level: hiring, planning, architectural decisions, managing developers, breaking down work into milestones, and owning outcomes instead of just tickets. I also worked in-house at Delivery Hero in Berlin, which added another dimension to my experience: operating in a larger product environment, dealing with quality expectations, coordination, stability, and systems that affect real operations at scale. Those experiences shaped the way I work with clients today. I am not just trying to finish tasks. I think in terms of product direction, delivery quality, maintainability, and long-term cost.
In the last few years, the biggest shift in software has been AI-native development. I embraced that shift early, but in a practical way. I do not treat AI as magic and I do not use it blindly. I use Claude, ChatGPT, Codex, Cursor, and similar tools to accelerate planning, coding, debugging, and implementation, but I still own the architecture, acceptance criteria, edge cases, and production behavior. That combination is what makes my current workflow powerful: over a decade of hard-earned engineering judgment, combined with modern AI tools that dramatically reduce waste and speed up delivery. This is why I can help clients build faster without turning their systems into fragile piles of generated code.
Today, the kind of work I do sits at the intersection of several hard problems: AI agents, RAG systems, SaaS architecture, backend-heavy workflows, payment infrastructure, automation pipelines, and Ethereum-based product logic. I like products that have moving parts. Products where multiple systems have to cooperate. Products where speed matters, but stability matters more. I work best with founders, startups, and small teams who want someone who can think clearly, plan properly, and then build with accountability from idea to working system.
So if I had to describe my journey simply, it would be this: I started by learning how software works in the real world, I moved toward stacks that let me build more ambitious products more cleanly, and I adopted AI-native workflows not to replace engineering judgment, but to multiply it. That is why I do this work the way I do now. Not because the industry changed and I followed it blindly, but because I kept evolving toward the kinds of systems that matter most: production-grade systems that solve real business problems, scale properly, and stay reliable after launch.