NetDespatch

Learn How NetDespatch Reduced Deployment Times by 80%

Download the Case Study

The Company

NetDespatch – the leading SaaS retail logistics integration platform, processing millions of transactions per month.


The Challenge

Reduce the time and pain required to manage complex deployments in a microservices enterprise environment, so NetDespatch can scale to meet growing business needs.

The Environment

  • Microservices architecture
  • Tools: Chef, Team City, Gradle, Artifactory, Git
  • Middleware: In-house microservices component architecture
  • Language: 100% Java

The Solution

Create an automated deployment process with XL Deploy and its Satellite module that allows product owners to safely deploy their own code globally… while enforcing the necessary controls.

The Results

  • Deployment time dropped by over 85%, from 2 hours to 20 minutes and still falling
  • Microservices architecture is enabled and supported. Deployments have become a “non-event” – they follow a standardized process and they can scale to meet demands
  • Better control over the overall process and better visibility: the team can see exactly where the process is – and what is deployed on which servers – at all times

The Situation

NetDespatch is the leading Software as a Service (SaaS) retail logistics integration platform for postal and parcel carriers.They process millions of transactions per month.

Their software is a key competitive advantage for them and for their customers, and they strive to use the most advanced technologies and processes to maintain their leadership. And as an integrator of services across tools and companies, NetDespatch has a complex environment with a lot of moving parts and global reach. To stay on top of their competition, they continually evolve their architecture and have been doing Continuous Delivery (CD) in one way or another for over 10 years.

With their significant number of components and large amount of configuration data, the complexity of their deployment process was rapidly outgrowing the capabilities of their existing tools and processes. The current process was not going to scale to meet the demands of what they needed to do.

So they set out to combine XL Deploy, Chef and their API/SOA lifecycle management systems to produce full platform provisioning and application deployment automation.

A Scaling Challenge

As NetDespatch’s business grew, they found that the number of steps required to deploy to production was growing in direct proportion to the complexity of the target environment. Their new code goes through four environments before release: from dev to an internal testing platform to user acceptance to production. Between configuration management and setting up the environment, deploying to their intricate enterprise environment had become unscalable. For one deployment, they might have 50 different versions of property files.

"We just want to hit go. We don’t want to do anything else." - Matthew Clark, CTO, NetDespatch

NetDespatch wanted to implement a tool that would enforce necessary steps and controls while empowering the Dev team to release code into the production environment quickly. Each deployment was taking about two hours, and they knew they could do better.


Spoiler: With the new process, they are well on their way to meeting their goal of deploying in 6 minutes. And they always know what is deployed where and what state it’s in.


Before implementing XL Deploy, NetDespatch also evaluated a workflow-based deployment automation tool from a large enterprise vendor. “However, even heavy discounts didn’t outweigh some significant deficiencies,” said Clark.

Key Reasons for Choosing XL Deploy

XL Deploy had a number of crucial features that NetDespatch needed for their deployments:

  • Version and dependency management is a key requirement for NetDespatch – if you try to deploy a microservice, the tool needs to tell you which other services and which other versions must also be deployed.
  • The ability to control things through the Command Line Interface (CLI) is very important. NetDespatch likes to control things at a very low level, and for them it’s all about automation. So having everything accessible through the CLI is a big win.
  • Another key feature is the ability to model everything, from the infrastructure and environment to the application itself and all the configuration data that goes with it.
  • XL Deploy’s agentless architecture is a huge benefit. They do not like deploying agents to their 200 nodes!
  • The Satellite module provides a reliable, scalable way to deploy to data centers all over the world.
  • Finally, the team finds it crucial to have clear visibility of what’s deployed where. No more risky manual processes for determining what has been deployed where and whether all the right things have been deployed along with it.

Slashing Deployment Time by 80%...and Still Going

Talk about rapid results! The team deployed their first microservice with XL Deploy just one day after downloading the evaluation copy. And they didn’t even spend the full day. “The route to first success with XL Deploy is quite quick. Ordinarily the time to success is so long... several weeks for other tools. With XL Deploy, you can start to use the tool in such a simple way, and you can have your first component deployed the next day. It’s a helluva win” observed Clark.

Compounding the challenge, NetDespatch has the kind of complex environment that is more typically found in very large entities, and often their platforms are not co-located. To cope with the challenges involved in deploying to servers worldwide, NetDespatch added XL Deploy’s Satellite module, which lets you reliably execute deployments to remote data centers.

Six months after evaluation, NetDespatch had most of their microservices handled by XL Deploy, and deployment times had plummeted from 2 hours to about 20 minutes. NetDespatch is now 100% automated in their provisioning: not just deployment of software but also of the platform. Even complex deployments now take no longer than a few minutes.

Clark added, “We will have a large number of microservices, and XL Deploy lets us support that. In the old school, we could not tell at a glance what was deployed to each platform. No visibility. With 100 servers, keeping tabs on our deployments would not be simple.”

“At the end of the day, it all comes down to scale. Deployment time no longer scales with the number of nodes we deploy. It takes the same amount of time whether there are 50 or 100 nodes, and you can easily see what was deployed. That’s one thing that put us off the workflow-based vendor. We tried to imagine what it would be like to deploy to 100 servers: all of the configuration items, so many steps to create for one environment, then five… How would that GUI look with 200 servers per environment, 5 environments…? How will we manage all the versioning?

“We know our new microservices will be deployable. If we follow the model, it will work. There’s a consistency you can guarantee.” “Because it’s model based, XL Deploy helped us to come up with a standard model that enforces best practices, and that propagates into the software,” said Clark.

Clark summed it up: “XebiaLabs is Agile and they try to eat their own dog food. That’s evident. XL Deploy allows us to move along with our microservices strategy, because other things aren’t taking so long now. We don’t have to do anything to deploy – just tell it there’s a new host and it does the rest. Now we have the ability to scale and maintain the quality level we require.”