My co-founder sent me a message last week: "I just realized we shipped more this quarter than my old team of 12."
There are three of us. We don't have a PM. We don't have a dedicated designer. We don't even have clear role boundaries—everyone does everything.
And yet, somehow, it works. We've shipped a product, acquired customers, and haven't burned out (yet). People keep asking how, so I figured I'd write it down.
The Problem with Small Team Advice
Most productivity content assumes you're either a solo founder (do everything yourself, obviously) or a larger team (delegate, specialize, scale). The 2-5 person stage gets ignored, probably because it's awkward—too big for pure improvisation, too small for real structure.
The Awkward Middle
At three people, you can't have dedicated functions. There's no "product team" to throw things over the wall to. But you also can't just wing it, because there's enough complexity that things fall through the cracks.
We needed structure that didn't feel like process theater.
Our System (Such as It Is)
One board, multiple views
We run everything off a single Gryphin board. Development, marketing, ops, sales—all of it. This sounds chaotic, but it's actually clarifying. When everything is visible in one place, you can't hide from trade-offs.
We use labels to filter by area (eng, marketing, ops) and by urgency. Anyone can see the whole picture at any time. There's no "let me check with the other team" because we ARE the other team.
Weekly themes, not sprints
We tried sprints. They felt too rigid for our stage—we might pivot direction mid-week based on customer feedback. Instead, we do weekly themes.
The theme sets intent without being prescriptive. If something urgent comes up (production issue, big customer request), we can flex. But we default to the theme, which prevents aimless bouncing between priorities.
15-minute daily async check-in
Every morning, we post what we're working on in the board chat. Not a meeting—just a quick text update. "Today: finishing payment integration, blocked on Stripe webhook question." Takes two minutes to write, two minutes to read what others wrote.
This replaced standups entirely. We tried standups for a month. They felt performative—three people telling each other things we mostly already knew while burning 30 minutes of peak morning energy.
Ownership labels, not role titles
We don't have fixed roles, but every task has a clear owner. You can't create a card without assigning someone. This sounds obvious, but "we should do X" is very different from "Alex will do X."
Ownership rotates based on who has capacity and who has relevant context. I might own marketing tasks one week and debugging the next. The point isn't specialization—it's accountability.
What Makes This Actually Work
Radical transparency
Everything is visible. My tasks. Your tasks. What's stuck. What's moving. There's no "I thought you were handling that" because everyone can see what everyone is handling. This requires trust, but exposure cuts both ways—it also means you can ask for help before you've wasted a week.
Low ceremony decision-making
At three people, you don't need tickets and formal processes. Someone says "I think we should do X" in the board chat. If no one objects in a couple hours, it's decided. If someone has concerns, we hash it out. Most decisions are easily reversible anyway.
Intentional over-communication
When you're small and remote, it's easy to assume others know what you know. They don't. So we over-communicate. "Hey, just talked to Customer X—they want feature Y by end of month. Adding to board." Takes 30 seconds, prevents misalignment.
Protecting deep work
We have a team agreement: mornings (until noon) are for focus work. No internal messages unless it's a production fire. We even mute the board chat notifications during this time. This gives everyone a guaranteed window for actual work, not coordination about work.
What Doesn't Scale
To be clear: this system has an expiration date. Some things that work at three people will become problems at ten:
- Single board visibility gets noisy as task volume grows
- Rotating ownership works when everyone can do everything; not when you need specialists
- No documentation is fine when all context lives in three brains; dangerous when you're onboarding regularly
- Async decisions work when alignment is high; harder with more perspectives
We'll evolve the system as we grow. But for now, at this stage, it works.
The Meta-Point
I think a lot of small teams adopt process too early. They read about how Spotify does things, or how Google runs projects, and try to implement a scaled-down version. That usually adds friction without adding value.
The goal isn't to have good process. The goal is to ship things. Process should serve that goal, not the other way around.
For us, right now, "one board, weekly themes, daily async updates, clear ownership" is the minimum viable process that keeps us shipping. When it stops being enough, we'll add more. But not before.
If you're at the awkward small-team stage, my advice: start with almost no process and add only what you actually need. You'll feel the gaps. And those gaps will tell you what's actually necessary versus what just sounds professional.
Nina is the co-founder of an early-stage SaaS startup. Previously, she worked at two larger startups and watched them make every process mistake in the book.