Seven months ago, I joined Durable as a Software Engineer. 150 pull requests later, I barely recognize the engineer I was when I started.
The Shift
At first, I was shipping features. Fix this bug, add that component, make this page work. Fast, visible, satisfying.
Then something changed. I started building the systems those features would run on top of.
AI generation pipelines. Streaming architectures. Component libraries with versioned schemas. Vector search using embeddings. Infrastructure that supports 8 languages.
const growth = {
month_1_3: "learning to ship fast",
month_4_5: "learning to build foundations",
month_6_7: "learning to design systems",
ongoing: "learning what scales",
};What Building Foundations Actually Means
It means writing code that other engineers build on. It means making architectural decisions without perfect information. It means refactoring more than you ship new code.
The biggest unlock was realizing that building reusable systems is not slower than hacking things together. It is just a different kind of fast.
A well-designed prompt registry makes every AI feature easier to build. A type-safe component library prevents an entire class of bugs. A streaming architecture changes how users perceive performance.
Technical Deep Dives
Vector Search: Implemented semantic matching using embeddings. Pre-computed vectors, stored them in the database, built similarity search. Turns out contextual relevance beats keyword matching every time.
Streaming Architecture: Real-time content delivery with progressive loading states. Users see content as it generates instead of waiting for the entire response. The performance gain is not in speed but in perceived speed.
Design Systems: Built component libraries that serve as both UI primitives and contracts for AI-generated content. Every component has a versioned schema. AI generates valid, renderable output reliably.
Internationalization: Automated translation pipeline supporting 8 languages. Translation updates happen with every feature. No translation lag.
What I Learned
| What | Why It Matters |
|---|---|
| Delete more than you write | The best code is code that does not exist |
| Type safety pays off immediately | Catch bugs at compile time, not runtime |
| Abstractions emerge from repetition | Build the abstraction after the third copy-paste |
| Streaming changes everything | Users care about perceived performance |
| Systems compound | Good foundations make everything faster |
The Velocity Paradox
People think startups mean moving fast and breaking things. That is half true.
You do move fast. But breaking things is expensive. The trick is building foundations that let you move fast forever, not just this week.
Good architecture is not about over-engineering. It is about making the next feature easier to build than the last one.
Where I Am Now
Still learning. Still shipping. Still making mistakes.
But the problems are more interesting. The systems are more complex. The impact is more foundational.
From features to infrastructure. From shipping quickly to shipping things that last.
The learning curve has not flattened. It just shifted from "how to ship fast" to "how to build things that scale."
Keep building.