DevOps and the Automotive Industry: Urban Science, a Case Study
DevOps release automation and Continuous Delivery practices have enabled Urban Science to accelerate their software delivery—saving time, lowering costs, and increasing productivity. Learn how they are helping auto-sellers to better their businesses.
Join the DZone community and get the full member experience.Join For Free
detroit, michigan has been the center of the american auto industry since the turn of the 20th century when henry ford churned out a few cars each day at his mack avenue factory. nowadays, in addition to ford, buick, cadillac, and the rest of the gm family call motor city home. behind all the horsepower and sheet metal of the production line, car manufacturers also employ numerous software applications and tools from various vendors as part of their business. one such organization in the automotive industry that you may not have heard of is detroit-based urban science—a company that is changing the way the car industry does business.
urban science is a global automotive retail performance expert that serves nearly every automotive oem in over 70 countries. from acura to volvo and just about every manufacturer in between, urban science is finding new and innovative ways for auto companies to increase market share and improve profitability. their goal is to identify and solve the toughest business challenges of this massive industry. they work with manufacturers to help them understand how people are buying, servicing their cars, and using their cars. basically, if there is any kind of statistic around the automotive industry, urban science is tracking and interpreting it. their work helps manufacturers gain insights across the entire product lifecycle. for example, not only can they tell you which ford dealer is selling the most yellow mustangs with ragtops, but they can give ford insights into how likely the client is to bring that car back to that same dealer for repairs, and, if they do so, what that means the client will do the next time they are ready to purchase a car.
you can imagine the infrastructure and software updates required to support such an operation—with its demanding customers, high-stakes business, and massive amount of data being collected from all over the world and analyzed 24/7.
mark priolo, software configuration manager at urban science, is tasked with this challenge. straddling the line between configuration management and release management, priolo is responsible for building and managing the software release processes and it environments to deliver urban science’s offering to its customers. and he’s doing it by implementing devops automation and continuous delivery (cd) as part their software delivery practices.
across its portfolio and various services, urban science develops and releases dozens of applications, developed and managed by hundreds of developers and it release managers.
as urban science’s applications continued to get more complex, their corresponding deployments and release processes became more complex as well. limited test coverage and lack of standardized processes and environments were delaying critical software rollouts to their clients, leading to missed releases. in addition, infrastructure utilization was inefficient, with growing infrastructure costs and increased management overhead. for the company to remain competitive and effectively serve its customers, something had to be done.
while urban sciences’ it operations teams were incredibly strong, the complex nature of these deployments continued to increase the likelihood of errors. it was identified that what was being asked of the ops team simply wasn’t sustainable. for example, there were teams that were rolling out applications which required having 15-page documents with go-to logic in them (i.e. “go to page 7 and do this…then go to page 3 and do this”). not only were the deployments complex and time-consuming to develop, the deployment process itself could take hours.
so, priolo set out to implement automation and cd practices to accelerate this pipeline—aiming to reduce manual tasks, one-off configurations, and deployment errors, while increasing test coverage, feedback loops, and release cadence.
doing so, however, was not without its growing pains.
the challenges on the path to continuous delivery
the first thing priolo was challenged with was figuring out what to automate . sure, the old way of doing things is painful, but at the same time, it was working. however, the fact was there was a ton of manpower going into doing things manually. even when the decision was made that, “yes, we should automate,” the question remained: should they try to automate what’s working or just concentrate on new stuff and make sure new builds are automated from the beginning. the initial decision was to focus on automating the delivery processes for only new applications and workflows, and–for the time being–keep the old processes as-is.
another challenge of automation was team-adoption . although the executive management recognized the need to adopt devops practices and implement cd, these practices were not required for teams to use. rather, teams were given a choice if they wanted to automate, or continue doing things the old, manual way.
after a while, the organization took a step back to analyze and re-evaluate their rollout strategy. it was clear things could be improved—and part of this realization came directly from looking at tickets assigned to old applications’ release processes that were over 2 years old, and were simply not progressing, while newer, cd-enabled developments were gliding through the pipeline. now, people were asking, “can we automate the old stuff, too?”
streamlining your path to cd
you are more alike than you realize
the fact was, that while every application’s code was unique, and some deployment processes required very unique configurations or tasks— 90% of the delivery process throughout the lifecycle was the same across all applications. priolo and his team set out to find those similarities in the commit-to-release pipeline across the different applications. once they could map the process, they came up with a robust pipeline model that would work with that 90%. they then proceeded to rolling out this pipeline, and all its inherent automation tasks, to about half a dozen teams who started using it.
the results were extremely encouraging: with a relatively small number of teams and applications included, the project had already saved over 1,800 man hours annually.
look at the big picture, focus on the biggest pain for the biggest impact
priolo approached automation by looking at it from the perspective of identifying the opportunities for big wins and focusing on those. the goal wasn’t to fix local processes that were broken along the way, but rather to discern pain points and give the most bang for the buck.
being a small team, priolo didn’t want to have automation creep—ad-hoc fixing of different processes for various teams to address specific scenarios. the focus had to have been on reusability, system-level view, and the ability to scale . these would allow his efforts to have the most impact for the entire organization, rather than achieving only local optimizations , which may not amount to much in the large scheme of things (- or – may just be moving the bottlenecks to other areas in the pipelines.)
therefore, urban science focused on three different pipeline models that would be applicable for the vast majority of use cases. by doubling down on those three, urban science can service the majority of teams and application, giving them just about everything they need.
bring others on board!
while the initial efforts to implement automation started off with just that half dozen teams buying-in, urban science now has over 70 teams taking advantage of that model. depending on the specific application and use case, some teams have chosen to release monthly, weekly, and even multiple times a day.
these three pipeline models and the standardization across teams allow the entire organization to become more agile, and increase product quality and release velocity and throughput. this sort of release cadence and speed was just not possible with trying to schedule times for manually manage all the processes and environments configurations involved in the delivery pipeline.
think ‘process as code’
after modeling the key release pipelines and standardizing their processes, urban science turned their focus on treating their process as code. using a technology that enabled them to essentially export their pipeline models and all related automation as code, they were able to have their devops processes themselves be programmable. this meant that they could be versioned, reused, and stored in their source code repository—along with their application code and environment configuration.
with the process itself being codified, urban science could more easily onboard new applications and teams, update their code to support additional use cases, and more easily extend certain pipelines for specific needs—achieving predictable, repeatable, releases processes across the organization.
do it end-to-end
to accomplish all this, urban science leveraged electric flow —an end-to-end devops release automation platform from electric cloud, to simplify build, test, deployment, and release of multi-tiered applications.
a successful devops transformation takes the right people and culture, the right processes, and also the right tooling. from a tooling perspective, it was crucial for urban science to have a unified, single platform that can support their entire end-to-end delivery process , across all teams, and be able to orchestrate all the point tools, workflows, and environments that are part of the process.
this ensured the ability to standardize their pipelines across teams and applications, and scale to support the entire organization (rather than cobble together a different chain of tools or snowflake configurations for various tasks). in addition, this provided both development and it shared control and visibility into their software pipeline, across development, testing, and packaging stages.
to ensure compliance and organizational control, the pipeline also supports both automated and manual approval gates as code is promoted to further stages along the pipelines and into higher environments. (for example, code can be promoted automatically upon passing a battery of test, or await a confirmation from a supervisor via the platform, before proceeding to the next stage.)
continuous improvement and the bottom line:
by adapting new ways of thinking and new technology solutions, urban science is now able to drive their software production within a release pipeline model. in this approach, all the tasks and workflows throughout the pipeline—from code commit to release into production—are being completely automated and standardized as much as possible across teams.
this has had a great impact on the business.
devops and cd are essentially a journey along a path to continuously optimize your software delivery, to improve it and organizational performance. automating the end-to-end release pipeline is what “greases the wheels” for urban science software innovation. now, the teams are freed to focus on developing great features, rather than on building ad-hoc workflows or doing manual work to manage the path that the code has to go through until it is ready to be released to end users.
devops release automation and continuous delivery practices have enabled urban science to accelerate their software delivery—saving time, lowering costs, and increasing productivity. they are now able to better serve their automotive clients—building new and innovative solutions that are changing the way auto manufacturers produce, sell, and services their cars.
urban science achieved:
- faster and more frequent deployments. urban science went from 12 deployments per week to 40 deployments a week.
- fewer person resources required. manual processes replaced by automation reduced person resources needed for deployment by 78%.
- fewer process errors. tedious, error-prone manual operations have been eliminated, improving predictability and reliability, and reducing the number of deployments needed.
- better software quality. automated deployments mean more time is spent testing instead of on the deploy process.
for a deeper dive into this story, watch the video replay of marc priolo talking about his experience .
Published at DZone with permission of Anders Wallgren, DZone MVB. See the original article here.
Opinions expressed by DZone contributors are their own.