Lean and Mean: How to Run Fast with a Limited Budget as a Startup

Throughout my career as a software developer turned manager, CTO, and founder, my goal has always been to optimize for delivery — getting the best and most stable product out there as fast as possible. It became almost a game, or even a hobby: finding methodologies to accelerate development by simplifying code, writing it correctly, leveraging serverless infrastructure, and so on. As a startup founder, CTO, and geek at heart, I want to share my thoughts and lessons learned about accelerating development velocity.

Code Complexity

Over the years, I’ve noticed that team size and development capacity are only loosely correlated. The most overlooked factor that ultimately determines development velocity is code complexity.

Each piece of code interacts — directly or indirectly — with others. A function may call another function, or a configuration change in one area might affect a completely different module. These potential interactions grow exponentially with each new addition, which means the time spent debugging, reviewing, and fixing grows exponentially too.

One fascinating shift is that due to the context window limitations in AI-based “vibe coding,” smaller, non-modular codebases can actually be developed orders of magnitude faster than large, modular ones.

Minimizing code complexity is the key to development velocity. The simpler the codebase, the faster you move — exponentially so.

Correct Engineering Management

Engineering management is an art — not just of hiring the right people, but also of dividing responsibilities so teams are blocked as little as possible during projects.

Two critical concepts must be implemented correctly: separation of concerns and modular architecture (ideally microservices). When concerns are properly separated, product managers can deliver features more easily because they can own vertical slices of the product that map directly to engineering teams. Allowing teams to operate independently is fundamental to development velocity.

A simple rule of thumb: platform and infrastructure should be horizontal; business logic should be vertical. Implementing this isn’t always easy, but it’s essential. For example, creating a BFF (Backend-for-Frontend) layer that proxies multiple microservices into a single application allows individual teams to develop their own microservices and business logic independently while maintaining ownership of both the operational and business aspects of their domain.

Writing excellent code is also critical for success. Startups can’t afford a high ratio of junior developers — especially with AI-assisted coding — because low-quality code is expensive to remove later. Junior developers should work on tasks designed by senior engineers, with their work carefully reviewed. Over time, they’ll mature into senior contributors capable of doing the same for others.

Vibe Coding

New startups have a huge advantage: they can begin with a lean, clean codebase and leverage vibe coding tools (e.g., Claude Code) to rapidly build initial versions. However, using these tools effectively is a skill that needs to be learned.

Vibe coding isn’t just about writing code. Coding agents are most useful when they can close the feedback loop — seeing how their changes affect the system. This can be done via API access (e.g., curl), an MCP server that interacts with front-end components, or well-defined goals with automated self-tests. Most of a developer’s time is spent verifying that code behaves as intended, not writing it — and the same applies to vibe coders.

While context windows remain limited and retrieval-augmented generation (RAG) tools for coding are still emerging, prefer smaller, less modular codebases. Strongly typed, opinionated languages and frameworks (like Go and TypeScript) perform far better than weakly typed ones such as Python.

It’s critical to master vibe coding tools and use all their features — MCPs, Claude Code skills, initialization scripts (e.g., CLAUDE.md), etc. Developers shouldn’t fear coding agents; they should embrace them as force multipliers. The backlog is always infinite — the goal is acceleration, not replacement.

Since Claude Code’s release, I’ve written more code than ever before. New codebases are dramatically easier to spin up with vibe coding.

Freelance Developers

Freelancers are often underrated due to concerns about IP ownership and reliability. Many assume freelancers can only build external components, but in reality, when properly integrated into core teams, they can be just as effective — if not more — than full-time developers, and usually at a lower cost (and with fewer complaints 😉).

The best approach I’ve found is to hire a strong technical lead (CTO / VP R&D / team lead) and assign freelancers to their teams. Let internal leaders own the code freelancers produce. This may slow things slightly, but it ensures that the resulting code remains part of the company’s long-term assets rather than disappearing if a freelancer moves on.

Summary

Building fast with limited resources is all about reducing friction and complexity — not adding more people or process.

• Simplify ruthlessly: Smaller, cleaner codebases move exponentially faster.

• Structure for autonomy: Separate horizontal infrastructure from vertical business logic so teams can ship independently.

• Leverage AI and vibe coding tools: Treat coding agents as accelerators and learn their full capabilities.

• Use freelancers strategically: Integrate them under strong leadership to scale efficiently without losing code ownership.

Ultimately, speed comes from simplicity, clarity, and force multipliers — not from headcount. A lean and mean startup runs fastest when its systems, people, and tools are all aligned toward one goal: shipping great software quickly and sustainably.