5 Tips for Startup Engineering Teams
Tags: agile, startup, productivity
Published: 2018-05-20 16:38:15

---
title: 5 Tips for Startup Engineering Teams
published: true
description: 5 simple things startup engineering teams can do to reduce stress and ship stuff on time
tags: agile, startup, productivity
---

Every single company depends on software, and startups are no exception. Software has gone from being critical to every business, to BEING the business.

Software creation is an art, a craft, and a process.

<blockquote>Building and shipping software is a marathon that lasts the entire lifetime of the company.</blockquote>

To ship software effectively you need to establish cadence, and a process. In this post we discuss a lightweight framework and tips that startups can follow to ship quality software regularly and effectively.

<h2>1. Setup sprints</h2>

To start, you need a light process for identifying what to build and how to actually build it. Teams that choose to ship without a process end up being chaotic, stressed out, and ultimately not successful.

Here is a light process, called sprint, that will help your team ship to production every 2 weeks.

The sprint starts with planning what to build. The features are organized into <a href="https://alexiskold.net/2014/03/23/action-and-idea-lists-for-lean-startups/">two lists</a> – all features you want to implement, and a subset of features you will actually implement in this upcoming sprint.

Before the beginning of the sprint, the team gets together and re-prioritizes all features. Once the ranking is complete, the top 3-5 features are moved into the list to be completed for the upcoming sprint.

<blockquote>Once the features are selected they are LOCKED for this sprint. You can’t add new features in the middle of the sprint.</blockquote>

This is critical. Making changes in the middle of the sprint throws off the timeline, and causes massive stress to your engineering team. Avoid doing this at all costs.

Similarly to having 2 lists for features, you will have 2 lists for bugs as well. Before the start of each sprint, re-prioritize all the bugs, and move the ones that need to be fixed into the list for this sprint.

Here is a sample setup for your sprint:

<ul>
<li>Planning:    3 days before the start</li>
<li>Fix Bugs:     Day 1: Wednesday</li>
<li>Fix Bugs:     Day 2: Thursday</li>
<li>Code:          Day 3-7: Friday – Thursday, except weekends 🙂</li>
<li>Test:            Day 8: Friday</li>
<li>Test:            Day 9: Monday</li>
<li>Ship:           Day 10: Tuesday</li>
<li>There are a few tricks to setting up the sprint.</li>
</ul>

<blockquote>Never release into production on Friday, or in the evening.</blockquote>

Why? Because things tend to break and then you might end up ruining your weekend or be stuck in the office all night.

The second trick is always fix the bugs first before coding new features. This way you are making sure that you are building new features on a solid foundation.

If your sprint is 2 weeks, you have 5 days to code new features. This is plenty of time assuming you broke down your features into small chunks. In fact, this system forces you to do that. You are always making progress, improving the product, and moving forward.

The last part of the sprint is testing and making sure you release quality software.

<blockquote>The last few days of each sprint should feel like a spiral.</blockquote>

You test, find bugs, and fix them. The closer you are to the release the fewer bugs you should find. Once there are no bugs found, you are ready to ship.

When you are in the home stretch of the release, it pays for everyone to focus on specific bugs or features together. When everyone is focused together you squash down a bug faster and then move on to the next problem. This strategy helps the entire team spiral down toward the release together.

<h2>2. Prioritize and handle emergencies</h2>

In addition to implementing sprints, get your team to always prioritize and stack rank features and bugs.

<blockquote>When everything is important, nothing gets done.</blockquote>

Create simple and clear language that everyone can adapt when talking about priorities. For example:

<ul>
<li>P1 – highest priority, business critical</li>
<li>P2 – important, needs to get done, but not critical</li>
<li>P3 – not important, nice to have</li>
</ul>

If there is a P1 bug that is found in production, and it impacts the business, you need to pause the release, and push a fix into production. This situation should be rare.

If you finding that this happens all the time, then you aren’t doing a good job testing and fixing bugs in the final stages of your sprints. You need to revisit how you are handling your spiraling down toward the release.

As you review your lists of features and bugs, you re-rank and re-assign priorities. It is totally fine to have priorities change between sprints, just not during the sprint.

<h2>3. Pair program and test</h2>

Agile software development comes with a toolbox of methods to help build high-quality software. My favorite two are pair programming and testing.

<a href="https://en.wikipedia.org/wiki/Pair_programming">Pair programming</a> is literally two engineers working together. One is typing the code and the second one is watching.

Pair programming may seem like a waste of time but it is actually a more effective way to code, especially critical pieces of your system.

<blockquote>Pair programming increases the quality of the code and establishes awesome camaraderie between team members. You create clear and bug-free code out of the gate.</blockquote>

Testing, and <a href="https://en.wikipedia.org/wiki/Unit_testing">unit testing</a> in particular, is another strategy to ensure quality code. It is actually pretty hard to write and maintain a body of tests for your code, but it is necessary and it pays off. After all, if you didn’t test something how would you know it really works?

There are two types of tests that are particularly helpful. The first set of tests is for critical pieces of your software; things that just can’t break. The second is a set of tests that exposes the bugs you find. Whenever you find a bug, first write a test that exposes it and then fix the code. This way you are certain that if the bug returns your test will catch it.

<h2>4. Refactor your code</h2>

Like anything else in the universe, software decays over time. This may not be as obvious because we don’t readily see rust in the code, but it surely is there. Over time, large-scale software becomes tangled and fragile, and needs to be <a href="https://en.wikipedia.org/wiki/Code_refactoring">refactored</a>.

<blockquote>The way to deal with this is to constantly refactor, or improve your software. Much like you go to the dentist for regular cleanings, you need to proactively clean your code.</blockquote>

Encourage engineers to remove unnecessary code, and constantly improve the software to make it better.

In addition, every 6-8 weeks schedule a cleaning and improvement sprint. In this sprint instead of business features, the team is focusing on cleaning up the code, making it better, and writing tests.

<h2>5. Create a happy and productive engineering team</h2>

It is really easy to grind down your engineering team, and most startups manage to do it quickly.

<blockquote>Startups thrive on chaos, but a chaotic approach to building software just doesn’t work. It is like trying to sprint through a marathon – you can’t do it.</blockquote>

Writing software is a highly creative and intellectually intense activity and requires a fresh brain, clarity, and a specific cadence. Software engineering can be either incredibly rewarding or incredibly stressful.

<blockquote>Setting up sprints and having clear priorities is a great first step to creating a happy and productive engineering team.</blockquote>

By creating cadence you reduce stress. By enabling your team to ship to production frequently, you are making the engineers happy. After all, there is nothing more rewarding than seeing the code you created work and make a real difference in the world.

Please share with us the strategies and techniques you use for building software in your startup.