The biggest architecture decisions rarely involve technology. They involve trade-offs. Over the past few weeks, I've been spending a lot of time redesigning a cloud platform. Interestingly, we've spent far more time discussing why than how. Should this environment run all the time? Or should it exist only when it's needed? Should we optimize for convenience today or flexibility a year from now? How do we balance cost, reliability, security, and future growth? None of these questions have perfect answers. Every decision makes something easier while making something else harder. That's what makes architecture so interesting. One lesson that keeps coming up is this: Good architecture is less about choosing the "best" technology and more about making deliberate decisions. The technology will change. Cloud providers will evolve. New tools will emerge. But the reasoning behind your decisions is what helps a team move with confidence months or even years later. I've also realized that documenting those decisions is just as important as implementing them. Code explains what the system does. Architecture explains why it was built that way. That context becomes invaluable as teams grow and systems become more complex. The longer I work in engineering, the more I believe that architecture isn't just a technical discipline. It's a way of thinking. What's one engineering decision you've made that seemed small at the time but had a much bigger impact than you expected?

Lovable is brilliant at the part you can see. The expensive part is the part you cannot. Getting a screen is cheap now. You can describe an app and have something real in front of you the same afternoon. That is genuinely new, and founders should be using it. Here is where it stops being enough. Two customers should see different things, and one of them sees the other's. A payment fails at 2am and nobody finds out until the quarter closes. You change your pricing and last year's customers are meant to keep the old deal. Someone asks for their data back. None of those are design problems. They are the reason a real build costs what it costs. So do both, in that order. Build the prototype. Actually build it. A weekend in one of these tools will teach you more about what you want than a month of meetings, and you will find out which features you never needed. Then get it built properly. You will get a better price for it too, because you can point at a screen instead of describing a shape. Built something and hit that wall? Send me what it does and I will tell you what is actually left between it and real paying customers. No pitch. If you already know it needs to be the real thing, discovery is $500 and refundable, with scope, timeline and pricing in writing within 3 to 5 business days.

Welcome to The Distracted Developer. This company was built around a pretty simple idea: technology should solve problems, not create more of them. There are businesses running important processes through spreadsheets, inboxes, copy-and-paste workflows, disconnected systems, and repetitive tasks that someone has simply learned to live with. There are also good ideas sitting on the sidelines because turning “I wish there were a way to…” into working software can feel like an enormous leap. That’s the kind of work we’re here for. The Distracted Developer builds practical solutions across: • Custom software and web applications • Workflow and business process automation • Data engineering and integrations • Backend systems and APIs • AI-assisted tools and workflows The approach is problem-first, not technology-first. Sometimes the right answer involves AI. Sometimes it’s an API, an automation, better data architecture, or a small piece of custom software. Sometimes the best solution is much simpler than anyone expected. The goal is the same: understand the real problem, build what actually helps, and leave behind a system people can use and maintain. This page will be where we share what we’re building, the problems we’re exploring, engineering lessons, and the occasional rabbit hole that comes with being a distracted developer. Good ideas deserve working systems. Let’s build them. #SoftwareDevelopment #Automation #DataEngineering #ArtificialIntelligence #TheDistractedDeveloper

For a long time, CitrusWorx mostly lived in architecture notes, GitHub repos, whiteboards, late-night experiments, and internal philosophy discussions. Now it’s starting to become real in public. Over 10+ WebEngine-related libraries are now available on NPM, including: - Seltzer - Nectarine - GrapeVine - Juice UI - KiwiPress - Sugar - DNS - Stenzil - WebEngine and more. What excites me most isn’t just publishing packages. It’s watching an ecosystem slowly form around ideas I’ve been refining for years: - contract-first architecture - modular systems - sovereign infrastructure - pipeline-driven execution - framework-agnostic design - scalable application blueprints The goal was never to create “just another framework.” The goal has always been to create systems that help developers, businesses, creators, and agencies build smarter foundations with less chaos and less lock-in. There’s still a massive amount of work ahead. But seeing these libraries move from private experiments into publicly installable tooling is a huge milestone for CitrusWorx and the broader WebEngine ecosystem. Slowly but surely: the architecture is leaving the whiteboard phase. https://lnkd.in/eNczvvQV #OpenSource #WebDevelopment #SoftwareArchitecture #TypeScript #NPM #CloudArchitecture #SystemDesign #DeveloperTools #Programming #BuildInPublic

UPDATE: Client Teams are coming soon to Kepteasy. Clients will be able to add additional team members to their account, giving multiple people access to the same projects, campaigns, invoices, files and other client-side features. And building this has reinforced a lesson I already knew—but apparently needed to learn again. 😅 If you're building software, a little foresight early on can save you an enormous amount of work later. There's understandably a huge emphasis these days on getting to market quickly. Build the MVP. Validate it. Don't waste months building things nobody asked for. That's generally good advice. But there's a difference between a feature you can easily add later and something that affects the underlying architecture of almost everything you build afterward. Client Teams was one of those things. I foresaw needing it. But at the time, I was pushing to get Kepteasy to market and get a working product in front of real users, so I left it for later. Sure enough, it became one of the first requests I heard from multiple clients. And I probably cost myself weeks of work by not building the foundation for it earlier. On the front end, this sounds like a fairly simple feature: Instead of one user representing a client, multiple users can belong to the same client organization and work within the same client-side experience. Simple enough. On the backend? Not quite. 😂 Kepteasy is built in Django, and because the original architecture assumed a more direct relationship between a user and their client data, changing that relationship after the platform had already grown meant touching dozens and dozens of views across multiple apps, along with models, permissions, queries, migrations etc Had the relationship been built into the foundation from the beginning, much of the code written afterward would simply have inherited that structure as the platform grew. Instead, I had to go back and retrofit that assumption across an already fairly large application. It became a bit of a maelstrom. The good news is that I'm not bolting the feature on or patching around the existing architecture. There's no Frankenstein code being created just to make it work. It's now working well on staging, but isnt finished. And then I get to do ALL OF IT again on production. Double the fun. :) So, for the SaaS founders and app builders out there, this is my takeaway: Before pushing something out of the roadmap, ask yourself whether it's really a future feature—or whether it's part of the foundation. If it's independent, ship without it and add it later. If it changes your core relationships, data model, permissions or architecture, think very carefully before saying, "I'll deal with that later." Later can become considerably more expensive. In this case, I rushed ahead and bought myself a lot of extra work and agitation. But the end result will be worth it. Client Teams are now well underway and will be live in Kepteasy fairly soon.

Most software is engineered to give you choices. Good software is engineered to give you peace. If you look at the standard playbook for building an app or a SaaS platform, the goal is almost always the same: features, features, and more features. Product managers love to brag about endless customizability, massive libraries of choices, and hyper-dense dashboard layouts. But as a systems engineer who builds for neurodivergent minds, I see a massive flaw in this philosophy. For someone experiencing executive dysfunction, time dilation, or intense choice fatigue, a screen full of endless "inspiration" and choices isn't helpful. It's a cognitive hazard. It forces the user to think like a database just to navigate a basic layout. When my co-founder and I build applications at Retro Violet Studios, our design philosophy is the exact opposite: Radical Simplification. We shouldn’t expect a user who is already mentally drained to parse through a maze of menus. The system architecture should do the heavy lifting behind the scenes, leaving the user with a clean, low-friction path forward. **True innovation isn't adding 10 new features to your product. True innovation is figuring out how to delete 5 steps from your user's daily mental load.** When you build with human cognitive load in mind, "less" isn't a limitation. It’s the ultimate feature. Builders and Designers: Where do you think modern software design crosses the line from "helpful" to "overwhelming"?

Over the past few months, I’ve been reviewing startup products, landing pages, performance, and accessibility. And honestly, some of the things I’ve come across are surprising. I’ve seen seemingly established startups still serving the default Next.js 404 page when users visit a broken link. It might seem insignificant, but it got me thinking: How many other things are startups overlooking in their products? - Landing pages that struggle to convert visitors. - Slow page loads that frustrate users. - Poor accessibility that excludes potential customers. - Inconsistent UI that makes products feel unfinished. - Broken user flows that cause customers to drop off. Your product doesn’t have to be perfect. But small issues can accumulate into a poor user experience and missed business opportunities. So, I want to offer free product audits to a handful of startups. I’ll review your product across areas such as UI/UX, performance, accessibility, and key user journeys, then share actionable recommendations on what could be improved. If you’re building a startup and want an independent perspective on your product, I’d love to take a look. Send me a DM with “UI AUDIT” and a link to your product. Let’s find the gaps and fix them. #ProductEngineering #UIUX #Startups #WebDevelopment #Accessibility

I’ve been thinking deeply about where we’re going with Huboly. One way I currently describe the vision is: Brevo-like customer engagement infrastructure, with an agentic AI operating layer. Today, most business software still requires you to understand the software. You create the audience. Build the campaign. Write the message. Choose the channel. Schedule it. Check the results. Then decide what to do next. But I think the next generation of business software should work differently. Imagine telling Huboly: “We have an event next month. Help me get 2,000 registrations from our existing community.” Huboly should be able to understand that goal, analyze your contacts and previous engagement, recommend a strategy, create the right audiences, prepare the campaigns, ask for approval where necessary, execute, measure the results and determine what should happen next. That’s much more than putting an AI chatbot inside a product. The AI needs to be able to reason, plan and safely use the capabilities already available within Huboly to get meaningful work done. Contacts, audiences, forms, Events, Call, Notes, WhatsApp, SMS, email, campaigns, workflows and analytics become tools available to the agent. Of course, autonomy must have boundaries: permissions, approvals, spending limits, rate limits and audit trails. We’re not trying to build AI that can do anything. We want to build AI that can do useful work safely. I think the evolution is: AI Assistant → AI Copilot → AI Agent → Autonomous Operations. And that influences how we think about the infrastructure we’re building today. Ultimately, I don't want Huboly to just be software you operate. I want it to become software you can give work to. That’s the direction we’re exploring.

The best projects I've worked on all started with a problem. The worst ones started with a solution. Someone wanted an app. Someone wanted AI. Someone wanted a marketplace. Someone wanted a dashboard. And when you asked why, the answer was usually some version of: "Because we think people will use it." That's backwards. Users don't wake up wanting software. They wake up wanting outcomes. They want to save time. Reduce risk. Make more money. Avoid frustration. The product is just the vehicle. One thing experience teaches you is that technology trends come and go, but the projects that succeed almost always begin in the same place: a painfully clear understanding of a problem someone genuinely cares about solving. The founders who start there tend to make better decisions all the way through the build. Because when every feature request, pivot, and roadmap discussion happens, they have something to measure it against. The problem. Everything else is just implementation. #productdevelopment #startups #founders

Last week I sat in on a call where a founder asked his engineering team how long a feature would take. Three weeks, they said. He said okay, but the investor update is in ten days, could they show something by then. Nobody in the room pushed back. Everyone just quietly agreed to build a version that would demo well but wasn't the actual thing. I've been in that exact room before. More than once. On both sides of it, honestly😂 as the engineer nodding along, and later as the person asking the question I shouldn't have asked that way. Here's what I've come to believe after watching this pattern repeat across companies: the gap between "what we're building" and "what we're showing" is where most technical debt is born. Not from bad engineers but from good engineers being quietly asked to perform readiness instead of build it. I think about this constantly with what I'm building now. It would be easy to rush a version that looks finished for a pitch deck. Nobody would know the difference for a few months. But eventually, the gap between the demo and the real thing always surfaces usually at the worst possible time, in front of the person you most needed to trust it. I'd rather move slower and be honest about where things actually stand than build something that photographs well and breaks the first time someone leans on it. That's a harder discipline than it sounds. The pressure to perform progress is real, and it's constant. But I think the founders who build things that last are the ones willing to say "it's not ready" out loud, even when a shortcut is sitting right there. What's the pressure you've felt to show something before it was actually ready?.