IONICWEBCREATOR
Engineering Journal
Product

Lessons Learned While Building Our Business OS

We build Business OS to run our own company, which means we feel every shortcut ourselves. Here are the lessons that only show up when you are the first and most demanding user of what you ship.

Jakir Hussian

Jakir Hussian · Founder & Engineering Lead

May 14, 202610 min read

Share

Updated May 20, 2026

Business OS is the operating layer of our own company — the CRM, content, people, and access systems a growing software business actually needs, built as one coherent product instead of a pile of disconnected SaaS subscriptions held together by spreadsheets. We build it because we run on it, and being your own most demanding user teaches you things a roadmap never will.

Lesson 1: Being your own first user is brutal and clarifying

When you use the thing you built every single day, there is nowhere to hide from a bad decision. A clumsy flow you might have shrugged off in a client demo becomes a small daily tax you pay yourself. That pressure is the best product manager we have — it kills vanity features fast and rewards the boring things that make daily work smoother.

Lesson 2: Invest in the foundation, then move fast

The first module is slow because you are not really building a module — you are building the foundation every future module will stand on. Layout, navigation, forms, tables, permissions, the shared component vocabulary. Get that right and each subsequent module gets dramatically cheaper, because it is mostly composition instead of invention.

ModuleWhat it mostly reused
CRM (first real module)Built much of the shared foundation
Content / CMSFoundation + a generic list engine + field library
People, Users, RolesFoundation + patterns proven in earlier modules

This is the compounding payoff of the architecture I described in How We Structure Modern Full-Stack Applications. A shared foundation is expensive exactly once. After that, it pays out on every module you ever build on top of it.

Lesson 3: One seam, many surfaces

Every module in Business OS follows the same shape: a config layer that describes it, a mock layer that stands in for data, a service layer that resolves it, and a UI built entirely against the service. This consistency is not bureaucracy — it means anyone on the team can open a module they have never seen and immediately know where everything is.

module patterntext
config  → describes the module (fields, columns, options)
mock    → stands in for the backend while the UI is built
service → the single seam the UI reads and writes through
lib     → pure functions (no I/O) the module is tested on

Lesson 4: Boring is a feature

The most valuable parts of Business OS are the least exciting: predictable navigation, forms that behave the same everywhere, permissions that are easy to reason about. Internal software does not need to impress anyone. It needs to disappear — to let the team think about their work instead of the tool. We treat that invisibility as the highest compliment.

This is the same day-after mindset from Building Software That Lasts Beyond Launch Day, applied to the software we depend on most. When your own company runs on it, longevity stops being a principle and becomes a daily necessity.


  • #Business OS
  • #Product Engineering
  • #Architecture
  • #Developer Experience
Newsletter

New essays, in your inbox.

Occasional, considered writing on engineering products that scale. No cadence promises, no noise — only when we have something worth your time.

One or two emails a month. Unsubscribe anytime.

Building something that has to scale?

If the way we think about engineering matches the standard you're after, tell us what you're building. We'll be honest about fit and outline a concrete first step.