Core Leadership Principle #3
When I was junior, I watched companies and teams measure success by big releases. The quarterly launch. The major version. The dramatic all-hands demo.
Everyone celebrated those moments. But between them? Weeks of invisible work. Teams grinding away, not shipping anything, wondering if they were making progress.
I followed that pattern early on. Work on something for weeks, ship nothing, then finally push everything at once. It felt normal. That's what I saw everywhere.
Then I joined a team that worked differently. Developers were constantly shipping. Not always full features. Sometimes just a test. Or documentation. Or a bug fix. But every single day, something tangible moved forward.
I asked one of them how they maintained that pace. His answer changed everything:
"Shipping to production is a puzzle. You can't place all the pieces at once. But you can place one piece every day. Eventually, you complete the picture."
That's when I learned: there is no day where you don't make progress.
What "Ship Every Day" Actually Means
This isn't about posting in Slack: "Here's what I did today!"
It's not a reporting requirement. It's a mindset.
Every single day, you should be able to answer three questions:
- What did I ship today? (Code, test, fix, documentation, unblocked issue)
- What am I improving today? (Skill, process, codebase, understanding)
- What's my next piece of the puzzle? (Next concrete step)
If you can't answer these, you didn't have a productive day.
The Puzzle Mindset
Here's what changed for me: I stopped thinking in "features" and started thinking in "pieces."
Old thinking:
"I'm working on the authentication system. It'll be done in two weeks."
Then two weeks pass. Authentication isn't done. Feels like wasted time.
New thinking:
- Monday: Shipped the JWT token generation logic with tests
- Tuesday: Implemented token refresh flow
- Wednesday: Fixed edge case with expired tokens
- Thursday: Added monitoring for auth failures
- Friday: Documented the auth flow for the team
Same two weeks. But now I have five concrete things I shipped. Even if "authentication system" isn't 100% done, I made real progress every single day.
What Counts as Shipping
You don't need to push to production every day. But you need to complete something tangible:
Code:
- Merged a PR (even a small one)
- Fixed a bug
- Wrote tests for existing code
- Refactored a confusing module
Not Code:
- Identified root cause of a production issue and documented it
- Wrote an RFC for a technical decision
- Updated documentation that was wrong
- Unblocked a teammate by answering their question thoroughly
Progress:
- Researched an approach and ruled it out (with evidence)
- Set up monitoring for a feature that didn't have it
- Improved CI/CD pipeline
- Created a runbook for on-call
All of these count. They all move the puzzle forward.
What Doesn't Count
"I worked on stuff today."
Too vague. What stuff? What's done now that wasn't done before?
"Still working on that feature from last week."
What part? What's complete? What's next?
If you go three days without shipping something tangible, you're stuck. Reset your approach.
The Daily Questions
Every evening, I ask myself:
1. What did I ship today?
Good answer: "I fixed the CSS bug blocking the UI team, wrote documentation for the new API endpoint, and got DBA approval for the database migration."
Bad answer: "Worked on the migration."
2. What am I improving today?
Good answer: "Learned how PostgreSQL handles concurrent updates - wrote notes on it."
Bad answer: "Read some docs."
3. What's my next piece?
Good answer: "Tomorrow I'm implementing the rollback plan for the migration."
Bad answer: "Continue working on migration stuff."
See the difference? Concrete vs. vague.
Small, Mergeable PRs
One practice that helps: keep PRs small.
Target: under 400 lines when possible.
Why? Because small PRs:
- Get reviewed faster
- Have fewer bugs
- Are easier to understand
- Can be merged daily
Instead of one massive PR with your entire feature, break it into pieces:
- PR 1: Database schema changes
- PR 2: API endpoints (behind feature flag)
- PR 3: Frontend integration
- PR 4: Tests
- PR 5: Enable feature flag
Now you're shipping something every day instead of waiting two weeks to ship everything at once.
Feature Flags Are Your Friend
Here's the trick: you can ship code to production even if the feature isn't ready.
Use feature flags.
Ship the authentication module but keep it disabled. Ship the new API endpoint but don't expose it yet. Ship the UI but hide it behind a flag.
This lets you:
- Deploy daily
- Test in production (with the flag off)
- Enable gradually when ready
- Roll back instantly if needed
Shipping to production daily, even with features disabled, keeps you honest. Your code has to actually work. You can't accumulate a month of untested changes.
When I Got Stuck
I was once building a complex hospital integration. Two weeks in, I'd written a lot of code but shipped nothing to production. It "wasn't ready yet."
My manager asked: "What have you shipped this week?"
I said: "I'm still working on it."
He said: "Can you ship any piece of it?"
That question changed everything. I realized:
- The data parsing logic worked - I could ship that
- The validation rules were solid - I could ship those
- The error handling was done - I could ship that
I broke it apart. Started merging pieces daily. Put them behind a feature flag.
Two weeks later, I flipped the flag on. Everything worked. Because I'd been shipping and testing pieces all along instead of waiting to ship one giant blob.
The Compound Effect
Here's what happens when you ship every day:
Week 1: Feels slow. Just small pieces.
Week 4: You look back and realize you shipped 20 things. Some small, some bigger. But 20 real, complete things.
Month 3: Your velocity is higher than people who work in big batches. Because you're not blocked. You're not waiting. You're always moving.
Month 6: You've become the person who "always gets things done." Not because you work harder. Because you work in smaller, continuous pieces.
This Isn't Micromanagement
Let me be clear: this isn't about reporting to anyone.
Nobody needs to know what you shipped today. This is for you.
It's a way of working that keeps you honest and moving forward.
Some days you'll ship a massive feature. Some days you'll ship one bug fix. Both are fine.
The point is: no day ends with "I just worked on stuff."
The Test
Tonight, before you stop working, answer:
- What did I ship today?
- What did I improve?
- What's my next piece?
If you can't answer, you're drifting. Reset tomorrow.
If you can answer all three, you had a productive day. Do it again tomorrow.
String together enough of those days, and you'll ship more than you ever thought possible.
Start Tomorrow
Pick the thing you're working on right now.
Ask yourself: "What one piece of this can I finish and ship tomorrow?"
Not the whole thing. One piece.
Then ship it.
The next day, ship the next piece.
That's how you build software. That's how you make progress.
One piece of the puzzle at a time.
This is part 3 of a 14-part series on Core Leadership Principles. Next week: AI as Assistant, Not Autopilot - how to use AI without outsourcing your thinking.
How do you track daily progress? What helps you maintain momentum when working on long projects?
Follow me on Twitter
If you like and want to support my work check my patreon
See more in https://linktr.ee/daniloab.
Photo by Tanja Tepavac on Unsplash
Top comments (0)