A Startup’s Operating System

By Esteban Reyes, Founding Partner

Abstract — TL;DR

People say “getting things done, quickly” is what matters most in startups. While I agree with the intent of such a statement, I dislike the fact that its cliche, ambiguous, and incomplete.

Effective execution isn’t just about getting things done quickly. Speed is super important in startups, but quite often founders are operating way too reactively. Investors can encourage this behavior by overweighting the value of responsiveness. And I’ve found that reactive, responsiveness can also be a leading indicator of poor execution.

Instead, I suggest the most important (and underrated) thing in startups is implementing a well designed operating system (OS) that interconnects vision, strategy, and tactics with output metrics. At an early stage implementing an OS can be seen as unnecessary, or confused with wasting time. But having an OS in place brings incredible clarity and focus, which leads to effective execution.

Inevitably designing and implementing an operating system takes time and energy, and also pays back in spades when done well.

This document isn’t a how-to guide or an exhaustive implementation manual. Its purpose is solely to provide founders and teams with a way of thinking about designing, implementing, and operating a startup.

Startup OS Principles

What powers an OS: people, obviously, and often the more experienced and intelligent the better. But a bunch of smart, driven people working together won’t always equate into a highly effective team. The speed and effectiveness of a team is largely dictated by the energy level of its leaders, and how good of an operating system they have in place. To deliver results smart people require clarity in their objectives, resources, authority, and guidance.

Main characteristics: IMO the best startup operating systems share five attributes in common:

1) Structured: designed so that all inputs and outputs interoperate toward the same objective(s).

2) Efficient: produce maximum output with minimal energy waste.

3) Adaptable: are easy to adjust to new conditions or requirements.

4) Instrumented: capture and report critical intelligence that operators can use to inform decisions.

5) Anti-fragile: “[a systematic] increase in capability, resilience, or robustness as a result of stressors, shocks, volatility, noise, mistakes, faults, attacks, or failures” — Nassim Nicholas Taleb, Antifragile: Things that gain from disorder (2012)

Out-of-the-box operating system methods likely won’t work: much has been written about OKRs, MBOs, Balanced Scorecard, etc, and most of these methods have useful elements. However, they’re hard for founders to implement and manage when put into the context of their startup, especially for first-time founders.

At Las Olas VC (a.k.a. LOVC) we’ve observed three main issues: 1) founders have it all in their head, are busy, and don’t want to allocate the time to codify it into an operating system, 2) they have difficulty settling on a few critical factors, 3) take a simplistic, piecemeal approach to goals and KPIs, which aren’t always connected to the big picture.

Building Your Operating System

Building your OS is like stacking Legos. While there are no rules a startup’s OS generally starts with the definition of a vision and ends with a performance dashboard your team can use to operate. The hard part is coherently defining and connecting everything that sits in between.

Below are all the key building blocks of a startup’s OS and how I like to piece them together:

  • Vision: the vision of a startup is what the founder(s) aspire the company’s future position to be. A good vision stands the test of time: it’s specific, anyone can understand it, and is highly aspirational. It rarely changes and instead becomes more clear over time.

Example of a Vision Statement:

  • Mission: the mission statement defines the startup’s business, and can serve as a compass for making hard decisions. It’s actionable and very simply explains what a startup is about and the problem it seeks to solve.

Example of a Mission Statement:

  • Objective(s): are the achievable, measurable milestones toward a vision. When designing a startup’s operating system the objective(s) must be clear, agreed to, and understood by all team members. There’re long and short-term objectives, which are typically stackable and interrelated. But typically there are only a few things that really matter — focus your best energy on those. This is what kills you if you don’t get it done.

Example of an Objective:

  • Strategy: is the method you apply to achieve your objective(s), and ultimately realize your vision and mission. A good strategy is explicit about it’s tradeoffs — it’s about what you do and doesn’t do.

Example of a Strategy:

  • Effectiveness Areas, Tactics, and Output Metrics: effectiveness areas (EA) is where you allocate resources to drive results. EAs need to be measurable and reportable. Tactics are the key activities you carry out day-to-day, and output metrics is how you measure the efficacy of your EAs and tactics.

Example of EAs, Tactics & Output Metrics:

Targets: define what success looks like, and help keep your team accountable. Targets quantify your team’s effectiveness. Focusing on the wrong targets can lead to inaccurate conclusions and misalignment. The most common mistake is confusing targets with effort. If a target doesn’t propel the organization toward its objective(s), then it should be revised.

Example of Targets:

  • Execution Dashboard: is the tool you use to measure performance. It’s the cartography that keeps you on track when navigating uncharted territory. Best to keep it simple and accessible to all team members.

Example of an Execution Dashboard

See a functional version here

Operating Your System

With defined building blocks you can “compile” your OS and put it to work. Operating your system requires an aligned team of artists and scientists. The Artists spend most of their time painting the “landscape of your startup”, and inspiring people to care about it. The Scientists develop, and master your startup’s method for creating and delivering value. When artists and scientists work together in unison operational excellence happens.

A key element to operating your OS is consistency and discipline. Operating isn’t sexy, and it’s easy to lose focus if you’re not paying attention. Use your operating system as a compass to keep the course toward your vision.

Consider the following:

  • Build an execution dashboard — make it a team exercise and let people have ownership, don’t try to push it down.
  • Set a cadence to review it regularly — this varies depending on the specifics of your company, your objectives, and your team’s working model — I’ve found that monthly is the bare minimum.
  • Name a chief dashboard officer — this person is accountable for making sure your execution dashboard is produced accurately, and on time.
  • Make attendance mandatory — your whole leadership team must engage in your OS meetings.
  • It’s a full-contact sport: “set it and forget it” doesn’t work. It requires ongoing monitoring and adaptation.


No OS replaces human intelligence, intuition, logic, and sound judgment, but it can amplify.

A startup OS is a team exercise, there are no rules, but it does require process and discipline. Its complexity changes over time as your team and company mature.

Key: Read, ask, and pick apart everything you can learn about methods for operating your startup. Come up with the OS that works best for you and your team and put it to work ASAP. Otherwise, you’re likely just lost in space and hoping for the best.

Favorite Resources & Things I’m Considering Writing About:

  1. Defining a vision and mission statement
  2. Setting objectives
  3. What is strategy?
  4. Defining effectiveness areas
  5. Setting priorities and effective work plans
  6. Measuring team performance
  7. Performance dashboards & tooling

This story is published in The Startup, Medium’s largest entrepreneurship publication followed by +390,426 people.

Subscribe to receive our top stories here.