Early stage startups often fail to keep up with development. How to avoid this?

Almost all early-stage startups go through a typical problem of wrong estimation of development tasks. One can solve this situation with a reasonable estimation of timelines and budget. The development process needs detailed requirements and prioritization and for early stage startups this approach becomes crucial.  

Nobody likes to estimate tasks. However, it is pointless to start development without clearly measurable tasks and valid requirements. Founders are often eager to quickly launch a project on a single feature without forming specific requirements for it. Limited resources can also play on a start-up when a low-cost contractor is hired for development and bills on the basis of an hourly rate. 

Such an approach is quite applicable when a young project has an experienced CTO who fully controls the timing and quality of development. Otherwise, a team of developers working on an hourly basis can delay the implementation of features for months and even years ahead. For an early-stage startup, such a scenario is similar to death. 

If you want to avoid wasted money you should, at the very least, spell out the requirements for the project at a basic level. Essentially, this is how the founders see the startup: the first key features and the order of their implementation, the goals and structure of the new business (monolithic or microservice architecture, integrations with other services, etc.). The founders will find it easier to explain what they want from the development team. 

Let's imagine that an early-stage startup has got its first investment and wants to hire a development team. The truth is it will be very difficult to find good developers quickly. In addition to the market salary, it is important to offer values and mission that will motivate the employee to work long and enthusiastically. One way to attract great staff is to talk a lot about yourself in niche social media and actively promote the startup to job seekers. Developing an HR brand requires considerable investment of time and money, so a startup can outsource urgent and complex development tasks.

When choosing a contractor, it is essential to consider their experience and achievements in a particular field. Such an outsourcing company may be slightly more expensive than a wide-ranging agency, but it has already learned many lessons and made valuable conclusions from other clients' projects. In addition, you can choose a contractor based on two development models in early stage startups:

• High-quality code, but it takes a long time
• Minimal attention to code quality, but fast  

There is no right way here, everything will depend on the amount of resources and the choice of the speed of feature implementation.

Startups are forced to hire inexperienced developers to save money. However, it often happens that such employees can waste precious time for the project. There are several factors that can attract a strong specialist to an early stage startup on the spot:

• An experienced professional has been wrong many times before and is now ready to share insights with a startup that benefits the community.
• A strong developer will be happy to see the results of his labor instantly. In large corporations, the effort-results cycle can take much longer.  
• The chance to get a good option and make an impressive amount of money in the long run. The probability is quite small, but it exists nonetheless.

When the first employees are hired, it's important to synchronize them and allow them to set their own goals. A proven way of synchronization is to set goals from the bottom up. This way, employees will begin to understand how they affect the growth and development of the startup. Then you can define 3-4 metrics for each goal to measure performance by.

Early stage startups can fail to keep up with development when the CEO has no management experience and hires staff poorly so that developers deal with the minor details and don't see the big picture. Problems with development processes can also arise when the CTO is constantly micromanaging the team. At the early stage SCRUM is not always an ideal solution, you can test your own methods of process organization. 

Meanwhile, to avoid problems with development and increase its pace, the CTO/technical lead can take consultations from competent specialists who have already solved similar problems. Or go further and engage an adviser to help build processes, hire a strong specialist, and establish communication with the community. As a rule, in return, a startup can offer the adviser a share of up to 1%.

Forgetting to update technical documentation is a long-term kill for development. In case the documentation is not very accurate, the team probably does not check its quality well, and there is no clear process for writing it. If there are no clear requirements for project artifacts the startup will have a hard time getting something specific and useful for development.

At the early stage of a startup, it is quite difficult to collect detailed information for documentation because the code will be updated and such documentation will fall into disrepair. In practice, it should provide at least an average level of immersion in the project details. A startup can start with such a set-up:

• project and architecture description
• developer agreement (how development is conducted)
• user documentation
• code description 
• API documentation
• list of functions and their role

It is important that the person who writes technical documentation also has time to work. Allocating a separate unit just for writing documents is an unacceptable luxury for an early stage startup. 

A strong influence on the speed of development in an early stage startup is the presence of a large tech debt. Therefore, it is important to keep an eye on its volume. 

Debt accumulates when immediate solutions are implemented without regard to best practices. The code becomes progressively more complex and can make it difficult to scale the product in the long run. 

If you have accumulated tech debt, it is important to attract resources not only for developing new features, but also for refactoring the code.

At a certain stage, the team may become uncomfortable working with the code base. This affects the growth of the startup and relationships between developers. 

Lack of attention to development best practices leads to software bugs, slower speed of services, etc.

To reduce tech debt, startups can take the following steps:

• Allocate time slots to fix problems. Here it is important to keep a balance between developing new features and "repairing" old code. Problems arising due to tech debt should be detected and solved in time, so you can set deadlines for the team to regularly optimize the code.
• Pay attention to the code quality. Avoid rewriting, but make accurate code straight away. The team can adopt a document on how to code, what practices to follow, when to perform code checks. 
• Make code refactoring. Refactor urgently if the developer is constantly unable to estimate the amount of time it will take to solve the task. You should refactor constantly, without long breaks. It is better to refactor a little, but regularly. At the same time, refactoring should not become a way for the team to avoid implementing new functionality. 
• Report tech debt. The entire team, stakeholders need to understand the impact of tech debt on the performance of an early stage startup. 

Estimating any task is the foundation for a development team in an early stage startup. Developers should get into the context of the task as much as possible and allocate at least 5-10% of the time planned for the task itself for analysis. 

When estimating the task, it is necessary to include time for self-testing, release and debugging. From the very beginning of a startup's life, it is advisable to detail technical documentation. 

The CTO can write a detailed structure for the team on how to solve a particular task in a top-level way. One should not micromanage, but empower employees to make decisions, make mistakes and correct them quickly.

Given the speed of processes in a startup, it is important to follow fundamental principles from the first days:

• Spell out the requirements for the project. Define on paper the first key features and the order of their implementation, the goals and structure of the new business (e.g., specifics of architecture, integration with other services, etc.). 
• In case of lack of competence and knowledge, contact experienced development teams with a good portfolio of similar projects. 
• Pay attention to writing technical documentation.
• Do not ignore tech debt. Invest time in code refactoring.