We're Building the Boring Bits First
Before chasing velocity, lay the groundwork - because rock-solid foundations are what let startups move fast without breaking everything later.
Conventional startup wisdom says: ship fast, validate, iterate. And while I get the value in that approach (especially when you’re finding product-market fit) - my 30 years of software engineering experience keep pulling me in a slightly different direction.
I just can’t bring myself to launch something on top of a brittle foundation. It’s not that I disagree with moving fast, I just don’t believe speed should come at the cost of stability.
There are parts of every software system that are always the same, no matter the use-case. And when you skip those “boring” bits, you will feel the pain later - especially when real customers start using your product.
I’m talking about things like error handling, logging, observability, traceability, authentication and authorisation management, transaction management, project structure, CI/CD pipelines, and a proper dev/prod environment setup. These are the things that no one brags about, but they’re what let you build fast later without everything falling apart.
That’s what we’re doing right now with Brainiac.
Before writing a single line of domain logic, we’re getting the foundation rock solid: architecture, infrastructure, and tooling. These aren’t just nice-to-haves; they’re the backbone of any reliable product.
I’ve been on the other side of my previous business. We got some of it right and it paid off massively. But some things we overlooked (logging and observability especially), and it caused serious pain. Having customers tell you something’s broken before you even know about it - is an embarrassing position I never want to be in again.
To the startups and founders reading this - here’s what I recommend you nail before building features:
Design a clean, modular project architecture
Set up proper error handling and logging from day one
Configure observability and traceability (yes, including logs and metrics)
Build your first CI/CD pipeline — even a basic one makes a big difference
Put in place a solid unit and API testing framework
Implement user registration and authentication
Add role-based authorisation management early
Set up both development and production environments properly
Establish consistent API standards and structure
Create a simple system to manage offline or async work (you’ll thank yourself later)
Write database scripts to reset and rebuild your DB on demand (clean slates are powerful)
With all of this in place, we’ve created a stable, testable, observable, and deployable base that lets us now dedicate all of our focus on real product features.
Yes, it’s a slower start. But once the groundwork is done, we can move with speed and confidence - no firefighting, no rewrites, no embarrassing surprises. Plus, if we need to change things or pivot, we can do this knowing we will always have a solid base to build upon. Having a solid foundation will also enable us to onboard new engineers seamlessly, catch issues early, and deploy frequently without breaking things.
Some might say this approach goes against the lean startup grain. Maybe. But to me, this is lean - we’re removing waste later by investing smartly now. Once this foundation is set, we can be truly agile - iterating on the product itself, not scrambling to patch broken plumbing.
So if you're starting something new, think about your foundation. Don’t skip the boring bits - they’re what make the exciting stuff possible.