small_avatar_AdrianR3.png

thumbnail_avatar_AdrianR3.png

avatar_AdrianR3.png

Adrian

small_avatar_Grzegorz.png

thumbnail_avatar_Grzegorz.png

avatar_Grzegorz.png

Grzegorz

GET IN TOUCH

I'm Luiza, the Head of Production at Bitnoise, a software development company. I also work as a development process consultant, focusing on team communication, project management tools, and efficiency. In this blog post, I will share some tips and tricks on how to organize your development process to keep it lean and efficient, using a real-world example from my collaboration with a London-based client. 

I will cover the importance of frequent delivery and client feedback, improved backlog management, and transparency in the development process. 

From this post, you will learn how my team and I delivered better, faster, and increased average sprint velocity by 35%.

#### **Background**
As a Head of Production and Project Manager, my main goal is to maximize the business value of projects. During my collaboration with clients, they expect three types of activities from me: 

- optimizing the development process, 

- speeding up delivery, 

- and generating savings.  


In this post, I will share how we achieved these goals with **a mobile front-end team** I collaborated with in the role of a Scrum Master. 

The company I worked with is an **international e-learning company with over 15 years of experience in the market**. Their solutions are used by millions of users worldwide. We were delivering for both iOS and Android platforms while trying out the Scrum approach for our development process.

#### **Measuring Success**
From what point did we start our reorganization process? From process metrics. What were they telling us? That we were inefficient and that we needed to understand why.  

The velocity chart displays the amount of work that was committed at the beginning of the sprint (gray bar) and completed at the end of the sprint (green bar). We used story points to measure the workload, and **chart no. 1** visualizes the velocity results from seven sprints before any of the process improvements were made. The measurements were taken in the middle of the year. Sprint velocity results suggested that the development process was not as effective as the company had expected, and only half of the planned tasks were eventually delivered (average CaC = 52%).  

**Chart no. 2** represents the sprint velocity results after 6 months of improvements. The measurements were taken at the end of the year, and **the effectiveness of the mobile team's delivery increased from 52% to 82%.**

**CaC = Completed / Commitment * 100%**

![ ](\uploads\blog-Boosting_efficiency_post01_73wsaA6BpWrq4vOUbw1Lzr.png)
![ ](\uploads\blog-Boosting_efficiency_post02_48PZie37iQTD0LuouVXtbJ.png)
For additional measurements of the development process effectiveness, we used the **burndown chart**. The burndown chart also represents the amount of work (in story points) that was completed in a sprint (2 weeks), but it also provides information about the history of story point completion and suggests any impediments in the development process.

Referring once again to the middle of the year period (so before any improvements were made) and **sprint no. 7** results, we noticed that our realization of the delivery plan was far from effective and perfect. The red line, instead of dropping down and getting closer to the gray line every day, was following horizontally. It meant that as a team, we were struggling with task delivery, and what's more, we were often adding new tasks to the sprint (shown as ups on the red line chart). We explored this situation further during the retrospective meeting and noticed that during **sprint no. 7**, we spent a lot of time waiting for requirement specifications and discussing excessively instead of focusing on development.

At the end of the year, after implementing all necessary process improvements, we measured **sprint no. 19** and **noticed a significant increase in our efficiency**. We were finally delivering and had minimized the gap between the realization and perfect plan lines. Although there were still ups on the red chart, indicating that we may have forgotten some tasks/requirements during sprint planning, we were able to present the increment by the end of the sprint.


![ ](\uploads\blog-Boosting_efficiency_post03_1xPIJErbzjEUjO2w6nSIYV.png)
![ ](\uploads\blog-Boosting_efficiency_post04_2ed0YhpBPBGulwyap3Bzs0.png)
So, what steps did we take to achieve this improvement in our software development process?

#### **Frequent delivery and client feedback**
One critical aspect of boosting mobile team efficiency was to implement frequent delivery and obtain regular client feedback. Our two-week development cycle always ended with a valuable increment, presented during a review meeting. **This allowed stakeholders to test the functionality and provide early feedback.** The review meeting included developers, the Product Owner, Scrum Master (the Scrum Team), internal clients such as business analysts and designers, and external clients. Moreover, together we discussed the backlog (requirements) and adjusted the plan for the next iteration (sprint).

For example, in a few sprints, we delivered an improved feature that allowed users to play, pause, skip, and seek the video. **The client's feedback after every iteration helped us identify some usability issues, which we addressed in the subsequent sprint.** This iterative approach ensured that the end product met the client's expectations, and we were able to deliver a feature that increased user engagement.

Regular retrospective meetings with the scrum team also helped us  identify areas for improvement. These meetings provided insights into  what went well and what didn't in our last iteration, offering valuable  information for planning the next steps.

Both review and retrospective meetings served as inputs for planning the next iteration, ensuring that the planning process also addressed necessary improvements and backlog adjustments.

These frequent feedback loops helped us minimize the risk of delivering unexpected results, set continuous process improvements, and foster better collaboration among team members.

#### **Improved backlog management**
However, at some point, we realized that poorly prepared requirements led to delays and inefficiencies in our development process. To address this issue, we took the following steps:       

- **Designated a single person (Product Owner) responsible for keeping the backlog up to date.** The Product Owner is the person who knows how the functionality should look and has the final say in its implementation. In our case, the Product Owner had a deep understanding of the client's industry and had been working with the client for over three years.     

- **Used JIRA as a single source of truth for the backlog.** This provided a central location for stakeholders to review the backlog during review meetings and for the technical team to discuss it during retrospectives and planning sessions.     

- **Organized the backlog as a list, with clear prioritization rules, issue types, and workload estimates (story points).** These steps helped us improve the quality of our requirements and streamline our development process.


Below, you will find the issue types that our team is currently using in Jira backlog:


![ ](\uploads\blog-Boosting_efficiency_post08_1oAJUGnZkAfJ8Knaqs1KiW.png)
Below, you can find the prioritization rules that our team is using in Jira backlog:

![ ](\uploads\blog-Boosting_efficiency_post07_tb5y0VLiEddmfgMgVQ4Pi.png)
- **Seek input from developers for technical analysis and involve designers and business analysts in refining requirements.** The Product Owner does not have all the knowledge about implementation details, so it's essential to get input from developers, designers, and business analysts when refining the requirements. Involving these team members in the refinement process eventually decreased the number of misunderstandings at the development stage. 

- **Ensure that all necessary requirements are finalized before the start of each sprint.** Having finalized requirements at the beginning of the sprint reduces uncertainty and ensures a smooth development process. Avoid changing these requirements at the implementation level.  


These improvements led to faster delivery, reduced time spent on unnecessary discussions, and increased transparency of what is going to be delivered next.

#### **Transparency and useful board flow**
Having a transparent and useful board flow is essential for an efficient development process. We customized our board flow to suit our team and sped up delivery. The board flow provides a visual representation of our development process, making it easier to track progress and identify bottlenecks.  

We have implemented **Work in Progress (WIP) limits** to quickly identify and address bottlenecks. As you can see in the example below, once we put three tickets in the "blocked" column, it becomes red. This means that developers should drop any ongoing work and quickly address issues with the Scrum Master or Product Owner so that they can support unblocking them. Why? Because without those tickets (requirements), we won't deliver what clients expect at the end of the sprint. Visualization is a vital practice in board management and supports fast delivery.  

Additionally, we used **burndown charts to visualize our sprint progress**, helping the team stay on track and adjust their efforts when needed. The burndown chart and up-to-date board became essential tools for our daily stand-up meetings, where we discussed our progress, identified any blockers, and ensured everyone was aligned with the sprint goals.

Below you can find the board rules set for our Mobile Frontend Team:


![ ](\uploads\blog-Boosting_efficiency_post05_5EDWNXN5NXg3eh0Nb97vmL.png)
#### **Conclusion**
In conclusion, by focusing on frequent delivery and client feedback, improved backlog management, transparency in the development process, fostering a collaborative culture, and measuring success, we were able to significantly boost the efficiency of our software development process. These improvements not only led to better quality products but also generated substantial savings for the client.  

Remember that every team is unique, and the methods we used might not be suitable for every situation. However, by continuously evaluating and refining your development process, you can unlock its full potential and achieve outstanding results.  

If you have any questions or suggestions, feel free to leave a comment below or reach out to me on social media. I'm always happy to help and share my experiences.

For the complete presentation and slides from the **Land on Moon event** (hubraum, Berlin), please check the video below.



Land on Moon #3

Land_on_Moon_3_-_Luiza_Kwiatek.mp4

small_blog-Boosting_efficiency_cover_high.png

thumbnail_blog-Boosting_efficiency_cover_high.png

blog-Boosting_efficiency_cover_high.png

Boosting the efficiency of software development processes: a real-world example

React Native teams

Backend teams

React.js & TypeScript teams

Migrations to React.js

End-to-end product development

PoC and MVPs

CTO as a service

Software audits

Process consulting

Services - Frontend engineering

Services

asdasdas

Case Studies

HRtech

EdTech

Expertise

Career

The Team

Company

About us

Blog

#### **Why do you need automation?**
 When working on a new feature, improvement, or bug fix, it is crucial to ensure that all changes adhere to the rules specified by the linting tools, such as [ESLint](https://eslint.org/)
 and/or [prettier](https://prettier.io/)
. Similarly, it is essential to run tests whenever changes are made to guarantee that there are no regressions.

 With a simple project setup utilizing ESLint for linting, and [jest](https://jestjs.io/)
 and [cypress ](https://www.cypress.io/)
for testing, at some point, you will need to execute the  following command:



 This is a lot to remember and as the project grows there can be more commands to run.  It can become annoying and repetitive really fast to run all of these commands by hand. Moreover, forgetting to run some of them can cause production builds to fail or introduce bugs that could’ve been easily avoided by executing these commands locally.

 It can become quite challenging to remember and manage all of these  commands, especially as the project grows. The list of commands can  quickly become overwhelming and repetitive to execute manually.  Additionally, forgetting to run some of these commands can lead to  production build failures or introduce bugs that could have been easily  avoided by running these commands locally.

Fortunately, there are tools available that can assist you in configuring all the necessary commands to run automatically whenever you need them, relieving you of the need to think about them ever again.

#### **Knock-out repetitiveness with Lefthook!**
[Lefthook](https://github.com/evilmartians/lefthook)
 is an incredibly useful, lightweight, and easy-to-configure tool that automates various aspects of your workflow, including code formatting, test execution, and more!

To begin, you'll need to install Lefthook in your project.





#### **Configure it with ease**
After the installation is complete, you can begin configuring Lefthook by creating a ``lefthook.yml`` file in the project's root directory.



So clean and simple! Now, whenever you commit changes, Lefthook will automatically execute all of these commands. Whenever you commit changes, you should expect to see something similar to this:

![ ](\uploads\blog-Leftook_post_01_6VHv6PDrJMZOEMQSUR0YMM.png)
If Lefthook is not firing, try running the following command:



#### **Built-in features**
 However, this script can be further improved. For example, there is no need to lint the entire project every time you commit changes. Ideally, linting should only be performed on the staged files. 

Moreover, it would be beneficial if the script could also handle fixing any auto-fixable warnings and errors automatically.

Lefthook has you covered with built-in lists of files that can be used for that exact purpose for example ``{staged_files}``.

Updated configuration will look like this:



- ``staged_fixed: true`` makes sure that any file that was changed by ESLint auto-fixing will be re-added to staged files.

- ``glob: “/*.{ts,tsx,js,jsx}”`` makes sure that ESLint is run only against javascript / typescript files within all the staged files.

#### **Running concurrently**
Running each command individually can be time-consuming, particularly when there are numerous commands involved. To expedite the process, Lefthook can execute all the commands in parallel by adding a single line to the configuration file, as demonstrated below:



- ``parallel: true`` will run all the commands concurrently, which should make the whole process a little bit faster.

#### **What else can be automated?**
 Another command that can be automated is the installation of packages whenever you merge changes into your working branch. Other developers may have added different packages at any given time, so it can be advantageous to install them automatically before starting your work.

How to achieve this in Lefthook:





Important to note: ``post-merge`` hook will not run if any conflicts were detected!

Whole lefthook.yml file should like like this:





#### **Conclusion**
Lefthook is a very powerful tool that can help with automating repetitive processes, thus improving the overall developer experience by allowing your team to focus on delivering code that will be linted and tested automatically.

It is very easy to configure in new and existing projects, so I highly recommend trying it out on your own!



small_blog-Lefthook_cover_high.png

thumbnail_blog-Lefthook_cover_high.png

blog-Lefthook_cover_high.png

How Lefthook helps improve development teams’ workflows

This year's [Vercel Ship](https://vercel.com/ship)
 event (May 1st - 5th, 2023) proved to be quite  interesting for Vercel users who find it a highly useful tool but  wouldn't mind some additional upgrades. Vercel introduced three major  innovations during the event, although it's important to note that some  of them are still in the beta-testing phase.

The new features are as follows:

1. Vercel KV: store key-value Redis, based on Upstash. 	 

2. Vercel Postgres: PostgreSQL database, based on Neon (beta). 	 

3. Vercel Blob: file storage, based on Cloudflare R2 (beta).  


At Bitnoise, we extensively utilize [Vercel](https://vercel.com/)
 for **developing, deploying,  and scaling websites and web applications**, both for our internal  projects such as [Land on Moon](https://www.landonmoon.co/)
 and while working for our clients.  Consequently, we closely monitor these changes and actively test the  available features.

In my opinion, once these new Vercel updates become available, they will greatly benefit us, especially during the MVP and PoC phases of software development. These phases require efficient time management, agility, and effective feedback from the end client for successful outcomes.

Now, let's delve into what Vercel is and how we utilize it.


#### **What is Vercel?**
Vercel is a cloud platform renowned for its **streamlined approach to website and web application development, deployment, and scaling**. It leverages a serverless architecture, allowing developers to create and host websites that seamlessly integrate both static and dynamic content. Vercel's key strengths lie in its user-friendly interface and exceptional performance, making it a highly effective choice for contemporary web development needs.  

The key advantages of utilizing Vercel in software development process are:  	  

- **Accelerated development**: Vercel empowers developers to iterate swiftly and collaborate seamlessly. Its user-friendly interface and comprehensive toolset facilitate a streamlined and efficient development workflow, minimizing the time spent on setup and configuration tasks.  

- **Scalability and performance**: Vercel incorporates built-in scalability features that ensure web applications can effortlessly handle high volumes of traffic. By automatically scaling resources based on demand, Vercel guarantees optimal performance and responsiveness for end-users.  	  

- **Continuous deployment**: Vercel simplifies the deployment process through seamless integration with popular version control systems like Git. With automated deployments and preview capabilities, developers can easily test modifications and confidently roll them out to production environments.


#### **How does Vercel benefit Bitnoise's software development process?**
As I mentioned in the introduction to the blog post, Vercel is a very useful tool that helps to speed up and improve our software development process, both for clients and internal projects.  

We have used and continue to use Vercel primarily for frontend applications. However, we have also used it for applications where we separated the frontend from the backend. Vercel enables us to **work seamlessly with testers who can immediately test individual changes before they are deployed to the production version**. It also offers quick configuration and setup for new projects, **significantly reducing the need for extensive DevOps work**.   

![ ](\uploads\blog-VercelChanges_post01_5xd70JrtoRsIKODvRhvRJg.png)
Here is an example of how we use Vercel:      

- Hosting websites and apps written in Next.js and Remix.     

- Integration with platforms like Bitbucket is a great convenience because it allows you to deploy your website or app directly from the repository using webhooks.     

- Creating hosting and testing environments, as well as staging environments for projects that are still in development.


#### **Use of Vercel in MVP and PoC**
What was mentioned before is especially important in [MVP and PoC](https://www.bitnoise.pl/services/proof-of-concept-mvp-development)
 phases of development when time and the possibility of consultancy and feedback from the client on every major change and development are crucial.

For me, it is particularly useful when we use Next.js to start any new application. Vercel's integration with Next.js simplifies the deployment process by **automating configuration, providing Git integration for seamless deployments**, enabling preview deployments for collaborative testing, supporting continuous deployment, and offering a secure and flexible way to manage deployment-specific environment variables.

In other words, it saves you time and effort, allowing you to focus on developing your Next.js app and delivering new features to your users with ease.

#### **How will the upcoming changes affect the future of Vercel usage?**
First, you need to keep in mind that most of these changes are still in the beta phase. There is a waitlist to test them, and it will take some time to fully introduce those features to new projects. However, based on our best knowledge and experience, as well as the information provided during the Vercel Ship event, there are some insights we can share: 

- **Vercel KV** upgraded serverless Redis implementation by leveraging the capabilities of Upstash. Redis, a widely adopted key-value store, is commonly utilized for tasks such as rate-limiting, session management, and application state. Vercel KV streamlines the process of creating Redis-compatible databases, enabling seamless read and write operations through Vercel's Edge Network in designated regions. This solution guarantees durability, simplicity, and minimal configuration requirements. By collaborating with Upstash, Vercel ensures the availability of serverless tooling that ensures data persistence in both memory and disk storage.  

- **Vercel Postgres** - PostgreSQL is a favored option for developers when it comes to handling relational data. In a collaborative effort with Neon, Vercel introduces Vercel Postgres, the inaugural serverless SQL database specifically designed for the frontend cloud. This innovative solution seamlessly integrates with popular frameworks like Next.js, Nuxt, and SvelteKit. Vercel Postgres offers comprehensive management, remarkable scalability, and fault-tolerance. It ensures high-performance and low-latency data retrieval, empowering developers to efficiently fetch data from Postgres databases and dynamically render content on the server.  

- **Vercel Blob** is a fast and efficient solution for storing files in the cloud. Powered by Cloudflare R2, Vercel Blob simplifies file storage by providing a storage API built on web standards. Developers can store various types of files, including images, PDFs, and unstructured data, without the need for complex configurations or heavy SDKs. With Vercel Blob, developers can easily manage files hosted on Vercel and programmatically upload or generate files during the build process.  Vercel's serverless storage solutions will enhance the platform's frontend cloud capabilities. Vercel KV is going to provide a durable Redis database, Vercel Postgres will officiate  a serverless SQL database, and Vercel Blob will simplifie file storage.   


**These changes are aimed at shortening the time of tests and deployment, and reduction of  extensive DevOps work.**  

#### **Conclusion**
Vercel's recent innovations and ongoing improvements position it as an excellent tool for accelerating project development, which is particularly crucial in the MVP and PoC phases. In my opinion, it can save around 3-4 days of work in a given project. With its user-friendly interface, comprehensive toolset, and integration capabilities, Vercel empowers developers to iterate swiftly, handle high volumes of traffic, and deploy changes seamlessly.  

Vercel has introduced new functionalities such as Vercel KV, Vercel Postgres, and Vercel Blob. These features aim to enhance key-value storage, provide a serverless SQL database, and enable efficient file storage, respectively. Although these features are currently in beta testing, they hold the promise of further optimizing the software development process and improving overall project efficiency.  

As Vercel continues to evolve and expand its offerings, it solidifies its position as a valuable resource for developers seeking speed, agility, and exceptional performance in their projects.



small_blog-VercelChanges_cover_high.png

thumbnail_blog-VercelChanges_cover_high.png

blog-VercelChanges_cover_high.png

How Vercel's upcoming changes will make it an even better tool for accelerating product development

Boosting the efficiency of software development processes: a real-world example

Luiza

How Lefthook helps improve development teams’ workflows

Michał

How Vercel's upcoming changes will make it an even better tool for accelerating product development

Piotr

GET IN TOUCH