If I could go back, the question I'd ask much earlier is: "How can we prioritize user feedback from day one?" In the early days of building SmythOS, I was laser-focused on technical precision, writing clean code, optimizing architecture, and building what I thought the market needed. But in doing that, I underestimated the value of early, messy, real-world feedback. Eventually, we shifted. We built in tighter feedback loops, shipped faster, and started listening more closely to how users were actually interacting with the platform. That pivot, which was putting users at the center, transformed our product velocity (SmythOS Product Hunt). It helped us move toward product-market fit much faster. And it ultimately led to the version of SmythOS that developers now share on Product Hunt and use at scale. Overall, I advise people to build with their users, not just for them. In tech, time is your most valuable resource, and early feedback is what keeps you from wasting it.
One question that would've saved a lot of time early on: "What problem shouldn't we be solving?" It's tempting to chase every request, build every feature, or dive into tech because it's cool. But not every problem is worth solving—some aren't core to the business, others add complexity without real payoff, and many can be solved with simpler workflows or existing tools. This matters because time, focus, and engineering capacity are finite. Saying no or deferring low-impact work is what separates teams that move fast with purpose from those that just stay busy. Clarity on what not to do is often more valuable than a long roadmap.
If I could rewind, I'd want to know how to recognize when to walk away from a project or idea that just isn't working. In my early tech days, I poured months into a tool that never quite fit the problem it was supposed to solve. I kept tweaking and refining, convinced that one more adjustment would make it click. Looking back, the signs were there: user feedback was lukewarm, and my own motivation was slipping, but I was too invested to let go. Understanding when to cut losses is crucial, yet rarely discussed. It's easy to believe that perseverance always pays off, but sometimes stepping back is the wisest move. That lesson would have saved me time, energy, and the chance to focus on projects with real potential. Now, I try to set clearer milestones and check in honestly with myself and my team. If something isn't working, I'm quicker to pivot or pause. It's not about giving up; it's about making space for better ideas to grow.
I wish I'd asked earlier, "Am I choosing this technology because it's genuinely the right tool, or am I just chasing the newest thing?" Early on I spent too much time experimenting with trendy technologies instead of doubling down on what I already knew deeply. The lesson was clear: mastering one tech stack and leveraging my existing expertise delivered quicker results than constantly chasing after every new framework, especially in the frontend world, where things move very fast. It's tempting to reach for shiny new tools, but depth beats novelty. Deep knowledge saves you from costly mistakes, accelerates progress, and ultimately leads to a stronger, more reliable product.
One thing I wish I had realised earlier in my development journey is how important context is when designing features or pages. During our university project for Alleysway, we were building a full web application, and there were several moments where we created a page that technically worked, but felt kind of... pointless. It wasn't until we took a step back that we realised the real issue: the page didn't make sense without something else to support it. For example, we had a bookings overview page that looked fine on its own, but without a way to view detailed session history or upcoming availability, it had no real value to the user. We had built it in isolation, without fully thinking through how the user would navigate the system and use it in the real world. That experience taught me that functionality means nothing without context. You can have the cleanest UI or most efficient logic, but if the user doesn't understand why they're there or what to do next, you've missed the mark. Now, whenever I build anything, I ask: "How does this fit into the bigger picture?" It's a small shift in thinking, but it's made a big difference in how I approach user experience, design flow, and even development priorities.
Looking back, the one thing I wish I had asked earlier in my development journey is, what's the minimum amount of complexity we can get away with? Early on, I assumed that the more technically elegant or customizable our platform was, the better it would be. So we spent time building advanced configurations, layered logic, and a lot of flexibility, thinking that's what users would value most. But in reality, most users just wanted something that worked fast, felt simple, and didn't require a learning curve. That realization came too late. And we had already overbuilt parts of our backend and UI. And simplifying after the fact is much harder than starting simple. So now, before we ship anything, first thing we do is ask ourselves, what's the lightest version of this that still solves the problem? What can we strip away without breaking the outcome? That mindset has saved us months of rework. And more importantly, it's helped us stay focused on value and not volume. To be honest, if I had asked that question from day one, we would've launched faster, iterated cleaner, and avoided building for edge cases instead of real users.
I wish I had asked other tech developers and entrepreneurs how they managed to maintain a good work-life balance! This was something that I definitely struggled with at the beginning of my journey, and it's still something I'm trying to figure out. With how rapidly the tech landscape had been evolving these past few years, I definitely felt a lot of pressure to get things done quickly, and because of that I often overworked myself. I would work late into the evenings, afraid that if I stopped, I would lose that "groove" and we'd fall behind. I ended up just feeling burnt out all the time, and that never helps when you are working on tech development!
One question we wish we had asked earlier in our tech development journey is: What assumptions are we making that no one's questioning? In early projects, we often took client briefs and internal processes at face value. That led to decisions based on outdated habits or unspoken assumptions like who the real end-user was or what success actually looked like. Now, before kicking off a build, we ask our team to write down the assumptions we're making about the user, timelines, tools, or hand-offs. Then we question each one. That five-minute exercise has helped us catch misalignment early and avoid hours of rework later. It's a small habit, but it's changed how we collaborate and deliver.
One of key questions I wish I had known earlier is - "What does it really mean to build for users, not just for specs?". Early in my career, I focused mostly on getting the tech right - clean code, elegant architecture, ticking all the boxes in a feature spec. What I didn't ask often enough was, "Is this actually solving the user's problem in the best way?" That shift in thinking came later, but it changed everything. It's easy to get excited about a clever solution or the latest framework, but users don't care about how smart the backend is if the product is confusing, slow, or doesn't do what they expect. Some of my most impactful work happened when I started sitting closer to the problem - listening to user feedback, watching how people actually used the tools we built, and working side-by-side with product teams. At Henry AI, for example, the biggest breakthroughs didn't come from adding more AI magic. They came from understanding where users were stuck - what slowed them down or broke their flow - and designing features that felt like a natural extension of their work. Building for users means putting yourself in their shoes and staying close to their pain points, even if it means simplifying your original vision. I wish I had learned that sooner: great engineering isn't just what runs efficiently - it's what helps people get things done.
One question I wish I had asked earlier is, "How will this scale under real-world conditions?" It's easy to get caught up in building features quickly or optimizing for the current user base, but without thinking ahead to scalability, you risk expensive rework and performance issues later. As we saw with some of our early-stage ticketing clients, a codebase that works fine with moderate traffic can quickly become unstable when sales spike. By asking this question early and investing in architecture reviews or code audits upfront, you can avoid bottlenecks and ensure long-term stability. It's a mindset shift from reactive to proactive, and it makes a huge difference in building sustainable, high-performing systems.
One question that I wish I had asked earlier is: "What are the long-term tradeoffs of this decision?" At the beginning of a tech career, it is appealing to optimize for what is best today: a framework, an architecture, a Band-Aid fix. But most technical decisions carry hidden expenses that only materialize over time: complexity, scalability boundaries, and maintenance burden. Forcing the consideration of long-term tradeoffs early on develops a mindset of durability over convenience. It's the difference between shipping code and building systems that can confidently be evolved.
I wish I'd asked earlier: "How much value is there in mastering the design-to-development handoff?" As both a web designer and developer, I finded that understanding both sides of this coin completely transformed my project outcomes. When building Asia Deal Hub, I initially treated UX/UI and development as separate disciplines. After creating a comprehensive design system (typography, colors, components), I saw project timelines shrink by nearly 2 weeks compared to previous projects. This single change improved client satisfaction and reduced revision requests by roughly 40%. Another revelation came from learning when to use visual builders versus custom code. With Project Serotonin, I initially planned a completely custom build before realizing Webflow could handle 90% of requirements without sacrificing quality. This pivot saved the client significant budget while still delivering emotional engagement that drove conversions. For anyone just starting, invest time understanding the entire website lifecycle rather than hyperfocusing on a single skill. My agency now completes typical custom Webflow projects in 6-8 weeks specifically because we've optimized these workflows between design and development—something I wish I'd prioritized from day one.
Looking back, I wish I'd asked earlier: "How do we properly structure data capture for future AI implementation?" At Scale Lite, I've seen dozens of blue-collar businesses with 10+ years of customer history trapped in unusable formats—handwritten notes, disconnected spreadsheets, or siloed in tools they can't export from. One restoration company we worked with had years of job data but couldn't leverage it for AI-powered scheduling or predictive maintenance because their information was scattered across five different platforms with no unified structure. We spent months rebuilding their foundational systems before we could implement any meaningful automation. The gap between collecting data and structuring it properly is massive. Many business owners think having information is enough, but without intentional organization, you can't train models or build predictive workflows. This matters tremendously because properly structured historical data is the fuel for AI implementation—without it, you're starting from zero regardless of how long you've been in business. If you're implementing any tech solution today, always ask: "How will this data structure enable or limit my ability to implement AI in the future?" This simple question has saved our clients hundreds of thousands in rework costs and months of lost opportunity.
One question I have always wanted to ask fellow developers is, "How does one balance learning the newest technologies with the basics?" I was always attracted to all things new; I was always experimenting with new frameworks and tools, often neglecting core concepts like algorithms, data structures, and system design. What I did was an imbalance: It gave me hindrance to really move forward because without core fundamentals, adapting to new technologies becomes after time, more difficult and consuming. That balance is an essential skill that remains not just trendy but everlasting, allowing one to solve complex problems and confidently pivot along technologies. Fundamentals allow one to create the kind of resilient skills that speed up learning and career progression in an ever-changing tech world.
If I could go back, there's one question I wish someone had punched into my brain from day one: "Are you building what you think people want, or what you secretly want them to want?" I know. Weirdly phrased. But it would've saved me years of head-banging frustration. Early on, I was so obsessed with being "smart" about product decisions—running surveys, analyzing user behavior, mimicking whatever feature Big Tech just dropped—that I didn't realize I was making stuff for a version of the user that didn't exist. Basically, a fantasy persona who thought like me, talked like a Reddit thread, and loved frictionless onboarding and minimalist UIs. Except... turns out, real users don't behave like your wireframes. They're unpredictable, emotional, irrational—beautifully messy. They click the wrong buttons. They get confused by things you thought were "intuitive." And worst of all: they don't care about your clever roadmap. They care about whether something solves their real, unsexy problem without making them feel stupid. It took me too long to learn that. I had to get slapped in the face by user feedback—multiple times. Only then did it click: I wasn't building for them. I was building at them. Why's that question important? Because once I asked it honestly, I started deleting things. Not polishing—deleting. Whole features. Entire flows. Stuff that felt "advanced" but didn't help. The product got simpler. More human. And finally, finally, it started working. So yeah. If you're in tech and you're not getting punched in the ego by your users once in a while, you're probably building in a vacuum.
I wish I'd asked earlier: "How do we fight commoditization from day one?" As someone who's launched dozens of tech products, I've seen companies pour resources into features while neglecting brand differentiation—only to watch their innovations become commoditized within months. Working with Element U.S. Space & Defense taught me that even highly technical B2B offerings need emotional connection. We transformed their digital presence by first identifying distinct user personas—engineers, quality managers, procurement specialists—then designing experiences that addressed not just technical specs but deeper motivations. This persona-first approach increased conversions by making their complex offerings feel personally relevant. The Robosen Optimus Prime launch exemplifies this principle in consumer tech. Rather than competing on specs alone, we positioned it as a collector's emotional journey. Our pre-launch strategy created anticipation through carefully timed content releases that highlighted nostalgic connections, resulting in pre-order numbers that exceeded forecasts. For tech developers, I recommend building your anti-commoditization strategy before writing a single line of code. Map your users' emotional journey alongside their technical requirements. At CRISPx, we've found that products that solve both rational and emotional needs command premium pricing even when cheaper alternatives exist—the ultimate measure of commoditization resistance.
I wish I'd asked earlier: "How do you balance proactive maintenance versus reactive problem-solving?" As a tech founder, I initially focused on putting out fires rather than preventing them. The turning point came during the COVID-19 pandemic when remote work exploded. Our clients who had proper device lifecycle management in place transitioned smoothly, while those without it struggled with security breaches and productivity issues. One client saved over $50,000 in emergency IT costs because we had implemented proper monitoring systems months before. What I've learned from 20+ years in IT is that cybersecurity isn't a product you install once - it's an ongoing discipline. At ProLink, we've seen attacks occurring every 39 seconds on average, and the businesses that survive aren't necessarily the ones with the most expensive tools, but those with consistent maintenance protocols. Understanding this balance between prevention and reaction completely transformed our service model and helped us grow from a small shop to a respected regional IT provider. The tech itself matters less than having systematic approaches to lifecycle management - something I wish I'd grasped years earlier.
I wish I'd asked earlier: "How do I design systems for scaling rather than solving immediate problems?" When building KNDR's donation platform, I initially created quick solutions that later required painful rebuilds when client volume grew 700%. The impact became clear when we shifted to modular architecture. Our AI donation system that now processes thiusands of transactions monthly was originally three separate tools cobbled together. Rebuilding with scale in mind let us promise 800+ donations in 45 days with confidence. This applies beyond just code. Our marketing automation was initially campaign-focused until we rebuilt it as an ecosystem approach. Now instead of creating one-off campaigns, we design interconnected systems where social media, email, and website components amplify each other automatically. For developers starting out: build with tomorrow's scale in mind, even when today's needs seem simple. Document your architecture decisions, create modular components, and remember that technical debt compounds faster than you think. The hour you invest in scalable design today saves 20 hours of emergency fixes later.
I wish I had asked earlier: "How do I design systems that scale alongside AI tools?" Early in building my markering automation businesses, I obsessed over individual tools rather than creating frameworks where they could work together effectively. This hit home when we built our first custom GPT workflows for a client. We had amazing AI tools generating content, but our delivery system was manual and bottlenecked. We lost weeks implementing a proper content pipeline that should have been designed from day one. The breakthrough came when we stopped viewing AI tools as individual solutions and started seeing them as components in larger systems. Now at REBL Labs, we start every client engagement by mapping their entire content ecosystem before implementing any AI. This approach transformed one agency's production capacity from 20 blog posts monthly to over 120 with the same team size - the difference wasn't better AI, but better workflows connecting their existing tools. For anyone working with AI today, understanding system design is your competitive advantage. The most powerful automation isn't about having cutting-edge models, but about creating intelligent workflows where each tool improves the next. Start by mapping your entire process before choosing any technology.
One question I wish I had asked earlier in my tech development journey is: "How will this scale six months from now, not just today?" Early on, it's easy to focus on building something that works right now, especially when you're juggling tight deadlines or client pressure. But I learned that just because something functions doesn't mean it's built to last or evolve with your business. At DIGITECH, we ran into this when we built a custom CMS solution for a client that met every need, in the moment. But when their traffic grew and their content demands increased, the backend started buckling. We hadn't designed with scalability in mind, so we ended up refactoring more than we expected just to keep up. That experience completely shifted how we plan architecture and workflows today. We now build with modularity, flexibility, and long-term growth baked into every project, even when the current needs are simple. Asking how a system or decision will scale forces you to think beyond launch, about performance, maintenance, user experience, and integration. It saves time, money, and stress down the road. It also changes how you communicate with clients, helping them see the value in building smart, not just fast. If I had understood that earlier, I would've made more sustainable decisions, and spent less time fixing things I could have planned for in the first place.