Navya’s primary challenge was handling product development complexity in a fast-growing organization. Their development team’s velocity was hampered by insufficient tooling (a mix of Git, spreadsheets, Jira, and other platforms) and tool friction that made traceability difficult to achieve.
Navya specializes in the development of autonomous driving systems. Founded in 2014 and headquartered in Lyon, France, it employs over 280 employees (140 of which are engineers and technology experts) across sites in France and the US. Navya was the first company in the world to release a commercially available self-driving shuttle. The company’s first fully autonomous, driverless, and electric AUTONOM® SHUTTLE was launched in September 2015 as a first- and last-mile passenger transport solution.
Today, Navya has over 160 self-driving shuttles operating in more than 20 countries. The company’s goal is to become the leading player supplying autonomous driving systems for passenger and goods transport.
In 2018, Navya launched a project to find development tools that could help the company manage the complexity of delivering high-tech autonomous driving solutions. Jules Garbé, Navya’s Head of Product Development (responsible for system specification but also development process improvement), joined the company just as Navya was wrapping up the Application Lifecycle Management (ALM) selection process that led to the rollout of Codebeamer. Jules’ team is responsible for delivering a single interface for all hardware, embedded software, and cloud-based software development activities in the company, and for ensuring the coherence of the overall product architecture.
The problem: Agile and ISO 26262 compliance
In early 2018, Navya’s primary challenge was handling product development complexity in a fast-growing organization. They needed a way to balance the flexibility of Agile and the rigidity of the V-model, while ensuring compliance with safety obligations.
This was the company’s startup era: The dev team didn’t have a system in place to manage product specifications, and requirements weren’t frozen while development was ongoing. Software teams were using Agile, with each team managing its own backlog. There was insufficient synchronization between teams, no procedures to follow, and no visibility into the process of development. All this was bound to conflict with the stringent regulatory requirements that govern functional safety in the mobility industry.
Before making the transition to Codebeamer, Navya’s dev team was using a mix of tools similar to the toolsets of so many other organizations. They used Git for versioning code and relied on a combination of manually updated spreadsheets, Jira, and a constantly growing document repository to stay on top of development activities.
As Navya’s teams were growing and product complexity was on the verge of starting to spiral out of control, the team saw risks that could have had a negative impact on development efficiency. The team didn’t wait for the situation to become so bad that it would affect operations. It was obvious that a methodological change was needed.
Safety and compliance in autonomous development
Navya develops a self-driving product with multiple safety-critical subsystems. As governing bodies are lagging behind product developers in delivering regulations for autonomous systems, ISO 26262 is still the most important regulatory requirement that Navya has to comply with in order to ensure functional safety.
From a process perspective, the dev team runs high-level risk analysis based on product use cases. Those are cascaded down into system requirements that are propagated to the required subsystems and components. To validate functional and dysfunctional requirements, the team conducts testing at the function or simulation level, stressing the software system in a controlled environment and then at the system level in a representative environment.
Once all these tests are passed, the product is validated and may be deployed —yet even after all this, the Navya team starts with a smaller, more controlled deployment with a limited number of customers. If that’s successful, the newly developed solution is deployed to the rest of the fleet.
Evaluating ALM tools with flexibility in mind
In July 2018, Navya initiated a sourcing process to select an Application Lifecycle Management solution. The search was fairly rapid due to a growing need to formalize development processes. In order to make an informed decision, the team analyzed the capabilities of several tools and started a discussion with multiple vendors.
The main factors that the Navya team was looking for as part of the evaluation included:
- The ability to custom configure various types of objects and to establish links between them for end-to-end traceability
- Ease of use in a fast-growing, innovative, Agile environment
- Collaboration support and an ability for users to interact within the tool
- Flexibility and the ability to evolve and adapt the system to support continuous improvement
- Ease of configuration as the team’s needs would be constantly changing as processed were improved
- Pricing model for optimal ROI
Like in software development itself, Navya’s development team took an Agile approach in building out their ALM environment. They wanted to proceed incrementally, following fundamental Agile patterns in the process to make sure the solution suited their evolving needs. The team sought maximum efficiency by continuously improving their working environment. Therefore, flexibility was a key requirement for Navya: Their tool of choice had to be able to adjust to and support a fully Agile mindset.
Having conducted the assessment process, Navya narrowed the search down to a shortlist of finalists that included Siemens Polarion and other tools. Eventually, it was this crucial need for flexibility that tipped the scale in favor of Codebeamer.
Navya purchased a handful of licenses in August 2018 and continued to progressively expand their number of seats. In 2019, there were 120 users of Codebeamer at Navya, with plans to reach 200 the next year.
Self-governing rollout and training
Navya had no previous experience in the scaled rollout of a development tool, and according to Jules, they hadn’t anticipated the success and growing demand they encountered with Codebeamer. Overall, Navya reported fast adoption of the tool, and very little effort was required to train users.
First, the goal was to use the platform for software bug management, which was shortly extended to user story and epic management for the software team. One surprising aspect of Navya’s experiences with the system came when the tool’s use was adopted by the hardware team.
Having used Codebeamer for some time, it felt natural for the product team to expand the tool’s use to hardware development—but management faced some resistance as the platform was perceived by hardware engineers as a software-only tool. However, it soon became very clear that Codebeamer was able to manage hardware problems and to reduce complexity, and so the hardware team’s buy-in was secured.
In terms of training, Navya took a hybrid approach: They did have formal training in place but saw more value in just letting engineers “play” with the tool. Once they learned how easy it was to configure Codebeamer, Navya decided to help spread the use of the tool organically by just handing out admin rights to many teams.
This approach proved to be a double-edged sword: On one hand, engineers did become adept at using and configuring the platform—but Navya’s dev team ended up with tons of unmaintained and heterogeneous objects that just couldn’t work together. To resolve this, they set up a team tasked with maintaining a systemic approach to using the platform, cutting objects, and reintegrating them under a shared framework.
Benefits of integrated ALM
By switching to Codebeamer, Navya primarily benefited from transparency, clarity, and consistency in their processes.
Before implementing Codebeamer, Navya’s teams were working in silos on various functional aspects of the product. Visibility into their activities was limited, and it was difficult to create a system-level view that would allow the team to handle complexity.
With Codebeamer, they are able to have an end-to-end view of development activities with links between all kinds of artifacts from requirements through to validation. Dependencies are easily tracked, and common-ground policies help standardize the quality of coding. The team can easily monitor progress and various high-level metrics to measure areas of focus. This helps spot problem areas to fuel continuous improvement.
ALM helped smoothen the compliance aspect of Navya’s development efforts, with traceable links going from high-level requirements through the organic architecture and back to final testing. This supports Navya’s team in conducting the necessary validation steps and compliance checks. Prior to making the switch to Codebeamer, these processes were not tooled, and Navya reported that using the platform had a beneficial impact on the team’s efficiency.
Considering the flexibility of the platform and all the benefits it provides, it’s no surprise that Navya is now investigating novel ways of adopting Codebeamer in the organization: