Simplifying Web Deploys

Pinterest is a social bookmarking site where users collect and share photos of their favorite events, interests and hobbies. One of the fastest growing social networks online, Pinterest is the third-largest such network behind only Facebook and Twitter.

In 2019, Pinterest has moved to a CI/CD model for our API and web layers, which has truly improved agility by reducing time between merge and production. Prior to the update, we had been deploying our web code in the same way for years, and it began showing its age. That mechanism is internally called A/B deploys and externally it’s referred to as Blue-Green deploys. In this post we describe how and why we replaced it with rolling deploys.

Our old deployment model (Blue-Green deploys)

Since the early days, the CD approach for the web layer of our main web property was based on the blue-green deployment model, where we kept two instances of the web layer deployed at all times. These instances were called A and B, therefore we commonly referred to this deployment model as A/B (not to be confused with A/B testing).

At any given time, only one of these instances would be active and taking traffic (let’s say A for example), so we’d deploy a new version to the other instance (B in this case) and switch over as soon as it had been verified with some canary traffic. B would then be on the latest version, active and receiving traffic. The cycle would then repeat with the next deploy happening on A and so on.

This model had a few positive aspects:

Instant rollbacks

When a regression somehow managed to make it past integration tests and canary traffic to be later on detected in production, we could instantly remove it by reactivating the previous version.

Only one version of the application runs at a given time

With only one of the instances active at a time and the cut-over happening virtually instantly, we could always rely on the fact that we were serving only one version of the application at a given time, which really simplified dealing with production metrics.

No capacity loss during deploys

Because deploys only targeted inactive instances, we could deploy very fast and then proceed to activate the new version when it was available everywhere. You can’t really do this that fast if you are updating production endpoints in-place.

However, things weren’t perfect. Here are a few things we didn’t like about this setup:

Need to keep two instances running

Since we had two instances of the webapp running at almost all times, our fleet had to be sized accordingly in terms of memory, disk and CPU. We also had to address other aspects of the instance duplicity, e.g. port and naming conflicts, which added complexity to our code.

No ramp up

To turn on a new version, we went from 0% to 100%. There’s a certain family of regressions that did not show up during canary phase and when they did show up, it was too late.


We had to maintain a lot of state in ZooKeeper to keep track of what had previously been served, when the new version became ready, etc. Over the years, the state machine controlling all of this grew wildly complex to the point where it was hard to change something without causing an incident.

Complex routing logic

The logic to ensure that requests were routed to the right version is hard to get right when you have more than a few possible states. We had to account for all the possible combinations of A serving, B serving, canary serving A, canary serving B, etc. This, coupled with logic to signal version upgrades to our Javascript code, made everything hard to maintain and even harder to extend that code base to support new use cases.


Most other stateless clusters at Pinterest use the well known rolling deploy model based on Teletraan, so there’s a real cognitive tax in having a hard to understand deploy model just for our web cluster.

The new deployment model (Rolling deploys)

Last year we decided it was time to move to a rolling deployment model. A cross-functional team was assembled to plan and execute the project, comprised of engineers across the delivery platform, traffic and web teams.

After exploring multiple approaches — each one essentially differing in how much complexity happened at the client vs the frontend proxy vs backend web clusters — we decided that we could handle the bulk of our routing logic in our Envoy ingress cluster.

Rolling deploys from the web application perspective

From the application perspective, the move to rolling deploys represented a fundamental change in the way we dealt with production metrics and issues: we could no longer simply rely on the fact that only one version was being served at a given time; in fact, mid-deploy we would have two different versions each running on half of the fleet. Therefore one of our action items was to update our systems and metrics to be more version-aware.

The version of our client-side application also became a key point of discussion, since we have long had a requirement for version affinity between the client-side and the server-side portions of our application. That means that 1) XHR requests coming from a client running a certain version of the app should be processed by server-side code from the same version and 2) our client refreshes to a new version when a new server-side version is detected.

Graph showing web client refreshes during the day, each color represents a new version being rolled out to the web clients. There, peaks coincide with the period when a new version is being deployed to our servers. At that moment, we signal to web clients that a new version is available on the server-side and instruct it to refresh. Once the deploy is complete, the number of refreshes rolls off until a new deploy starts.

We decided to maintain this approach since it provides a number of benefits in terms of development and operations as a consequence of the consistency between client-side and server-side code. However, with rolling deploys the cut-off to a new version is no longer a single point in time but instead a longer interval where two or more servers versions can co-exist. We quickly learned that we would need to roll the client updates along with the server-side updates to maintain a healthy ratio of requests per host while keeping the version affinity mechanism.

A day in the life of the Pinterest web app.

The graph above shows active user sessions, with each color representing a different version.

Notice how we “roll” web clients from one version to the other following our deploys throughout the day. The smaller blue peak represents a deployment that was rolled back when an issue was identified before its completion. It shows one of the many advantages of this model: early incident detection.

Rolling deploys and traffic routing

Last year, the Traffic team replaced our ingress tier based on Varnish with the new and powerful Envoy proxy. Envoy is easily extensible via filters which can be written in modern C++. The ability to extend our edge load-balancers with custom functionality and powerful metrics gave us confidence to explore a replacement for the Blue-Green deployment model. We set out with the goal of having an almost identical deployment model to every other cluster, while maintaining version affinity between client and server during deploys so that the Web team can carry on with the existing premise. This is also important, because switching across versions comes with a cost (e.g.: a browser refresh). So this needs to happen at most once for every active Pinner during a deploy.

We first simplified the client-side logic to ensure that the state machine which handles version switching had only one entry point, to make it easier to operate. Because of our unique requirements we couldn’t just use Envoy’s existing routing mechanism. Our requirements were:

  • During deprecation, both deployment types should be supported (Blue-Green and Rolling)
  • We should be able to gracefully shift over a % of traffic across stages
  • Behaviors should be as deterministic as possible. E.g.: when forcing an existing session into a new version, it shouldn’t jump back to the previous one unless there’s a rollback

So, we designed and prototyped a routing filter that would be in charge of distributing requests during a rolling deploy, while honoring the above requirements.

The first requirement is critical, and most successful migrations are so because they provide a good story around gracefully moving from the Old World into the New World. This allowed us to build confidence while we moved along, even though it came with a tax of supporting more complexity.

The Envoy filter’s state machine ended up looking something like this:

  • If a request has no routing id, assign it one
  • For a given routing id, pick a stage. E.g.: hash(routing_id) % len(stages)
  • Within a given stage, if it’s using rolling deploys then pick a version. E.g.: hash(routingid) % len(versionsforthatstage)

To avoid permanently sticking users to a stage, we established that a routing id has a duration of 24 hours. We also came up with the concept of a Route Map, which describes the traffic distribution across stages and versions. Here’s an example map:

This route map will send 99.5% of traffic to prod and 0.5% to canary. Within each stage, it’ll distribute traffic dynamically and consistently across versions. Dynamically means it’ll route based on the available capacity for each version. Consistently means it’ll apply an ordering between a routing id and the available versions to ensure a given routing_id is not jumping across versions during a deploy and that it only jumps once.

The route map is stored in ZooKeeper and distributed via our config pipeline. The capacity per version per stage is calculated from the available endpoints on our published serversets (which also exist in ZooKeeper). That is, endpoints have metadata about their versions which is then used for capacity calculation. This was all very convenient, because we could rely on existing and battle tested systems. However, it also comes with the challenge of eventual consistency. Not all Envoy servers have the same view of the world at the same time.

To work around this, we extended our filter to give it the notion of “deployment direction”. That is, when a route map is changing you can infer which version is being deployed by observing how capacity changes. A version that is increasing in capacity is the new version. Thus, when there’s a mismatch between the version a session wants versus what the filter thinks it should get we use the deployment’s direction to break the ambiguity. This ended up being very useful for quelling the version bouncing happening because of lack of synchronization across Envoys.


Deployment strategies and traffic routing are fun challenges. Getting them right can really smooth out your developer and operational experience. They can also greatly increase your reliability, when the pipeline is easy to reason about and debug. Being able to build this on top of Envoy really made things easier, given the vitality of the project and how easy it is to extend its core logic via filters.

Changing core infrastructure that has been around for years is always challenging because there’s a lot of undocumented behavior. However, our approach of a phased transition across deployment models made it possible to get steady feedback and ensure an incident-free migration.

This project was a joint effort across multiple teams: Delivery Platform, Core Web, Service Framework and Traffic. During the process we also received very valuable feedback from other teams and actors.

Credits for design ideas & code reviews: James Fish, Derek Argueta, Scott Beardsley, Micheal Benedict, Chris Lloyd

We’re building the world’s first visual discovery engine. More than 250 million people around the world use Pinterest to dream about, plan and prepare for things they want to do in life. Come join us!

Pinterest is a social bookmarking site where users collect and share photos of their favorite events, interests and hobbies. One of the fastest growing social networks online, Pinterest is the third-largest such network behind only Facebook and Twitter.
Tools mentioned in article
Open jobs at Pinterest
Engineering Manager, Advertiser Inter...
San Francisco, CA

Pinterest is one of the fastest growing online ad platforms and our success depends on managing our Ads well and keeping them safe for our pinners. The Advertiser Interfaces & Growth team is uniquely positioned to help our advertisers and our partners create and manage their campaigns. You’ll be joining an early stage team that is growing quickly and laying the foundation for Pinterest’s business success.

What you’ll do:

  • Collaborate with stakeholders across the organization to architect solutions that optimize our products and tools required to support the growing number of Pinterest advertisers
  • Provide technical and team leadership on rapid short-term projects/feature development as well as longer-term development of new services
  • Partner with product management to set engineering priorities, estimate scope of work, define release schedules, and track progress
  • Actively foster high-quality software development through code reviews, pair-programming, and targeted feature development and when needed to unblock the team, prototype new technologies and systems, or demonstrate good coding practices
  • Mentor and develop engineers and engineering managers
  • Enable and enhance production readiness of the broader ads manager ecosystem

What we’re looking for:

  • BS in Computer Science or a related technical field
  • 8+ years of experience as an engineering manager, preferably managing managers
  • 7+ years of software engineering experience as a full stack or backend engineer
  • Track record of developing high quality software in an automated build and deployment environment.
  • Experience leading a team of engineers through a significant feature or product launch in collaboration with Product and Design.
  • Experience with 1 or more of: Python, Java, JavaScript (Node.js, React, Angular)
  • Well versed in agile development methodologies (i.e. scrum, kanban)
  • Experience with ad tech a big plus


Partnerships Engineer
San Francisco, CA

The Business Development team at Pinterest leads partnerships across a diverse set of companies to provide our Pinners with world class experiences bringing them the inspiration to create a life they love. As a Partnerships Engineer, you’ll work with a variety of partners across Pinterest products (Creators, SMB, Ads, Shopping, Growth, Search etc) to define and build scalable Partner solutions, helping hundreds of millions of people find ideas and inspiration. You will be the evangelist of Pinterest’s technology stack, both internationally and domestically.

What you'll do:

  • Be a subject matter expert in Pinterest’s products and their underlying implementation
  • Define, develop and scale adoption of Pinterest partner products with strategic partners
  • Influence partners to build strategically viable technology using Pinterest’s tech stack, and work with these partners to make their launch successful in market
  • Collaborate with cross-functional teams on developing an overall developer ecosystem vision
  • Work closely with PM and Engineering teams to build right products per partner needs
  • Develop tools, processes, documentation and sample code to launch and scale partner products.
  • Represent Pinterest at developer events

What we're looking for:

  • BS in Computer Science or equivalent technical degree
  • 3+ plus years of software engineering experience, ideally in large consumer tech or any platform tech company with a strong ecosystem approach
  • Experience in partner/client facing roles or in product
  • Experience in large scale API/SDK based implementations
  • Deep understanding of mobile and web technology stack
  • Ability to read and write code as part of the standard web stack (HTTP, HTML, JavaScript) and familiarity with programming languages such as Python and Java


Engineering Manager, Shopping Discovery
Palo Alto, CA

The shopping team at Pinterest is inventing a brand new, more visual and personalized shopping experience for 300M+ users worldwide. Shopping is at the core of Pinterest’s mission to help people create a life they love. Every day hundreds of millions of users (Pinners) come on Pinterest to find inspiration to decorate their home, to wear outfits on different occasions, host parties and various other things to create a better life. Those inspirations are visual and reflect very detailed tastes of the Pinners regarding the choice of color, style, etc. The shopping team is responsible for connecting inspiration to products that Pinners would like to buy and create a life they love.

Connecting inspiration to product is very challenging and requires an understanding of user preferences, the content of the image, visual matching of images and selecting and ranking the top images based on various signals. More interestingly, we need to solve these challenges at the awe-inspiring scale of Pinterest for 300M+ users, tens of billions of inspiration pins and hundreds of millions of products. The team is using one of the most sophisticated computer vision techniques for image matching, deep learning for user understanding and ranking at the scale unimaginable at most places. If you are excited to improve lives using the magic of AI/ML at a very large scale then you must consider this position.


What you'll do:

  • Lead and manage the Shopping Discovery team of 7+ machine learning scientists and engineers in Palo Alto
  • Lead the effort to develop and improve shopping recommendation and search
  • Help drive technical strategy and longer term vision for Shopping at Pinterest
  • Spend 60% time on technical leadership/IC work and 40% time on people management
  • Use machine learning / deep learning techniques to solve some of the most large scale recommendation and search problems in the industry
  • Collaborate with partner teams like product, organic search, recommendations etc.

What we're looking for:

  • Ph.D. and 5+ years of experience or Masters and 8+ years of experience
  • Engineering Management experience for team of 5+ ML Engineers
  • Strong machine learning background within search, recommendations or similar ML problems




Senior Engineering Manager, Homefeed ...
San Francisco, CA

Homefeed is a discovery platform at Pinterest that helps users find and explore their personal interests. We work with some of the largest datasets in the world, tailoring over billions of unique content to 330M+ users. Our content ranges across all categories like home decor, fashion, food, DIY, technology, travel, automotive, and much more. Our dataset is rich with textual and visual content and has nice graph properties — harnessing these signals at scale is a significant challenge. The homefeed ranking team focuses on the machine learning model that predicts how likely a user will interact with a certain piece of content, as well as leveraging those individual prediction scores for holistic optimization to present users with a feed of diverse content.

What you’ll do:

  • Technical lead and engineering manager for the Homefeed Ranking team in San Francisco
  • Help drive technical strategy and longer term vision for machine learning and recommendation at Pinterest
  • Lead a senior team of 10 Machine Learning engineers
  • Hands-on role, spending 60% time on technical leadership/IC work and 40% time on people management
  • Use machine learning / deep learning techniques to solve of the most large scale recommendation problems in the industry
  • Collaborate with partner teams like product, data science, business, ads

What we’re looking for:

  • Graduate degree plus 5+ years of industry experience 
  • Technical lead experience and some engineering management experience 
  • Strong machine learning background within ranking, recommendations, optimization or similar ML problems


Verified by
Tech Lead, Big Data Platform
Software Engineer
Talent Brand Manager
Software Engineer
You may also like
3 Ways to Run Kubernetes on AWS
The Business Case for Container Adoption
Powering Pinterest Ads Analytics with Apache Druid
Best Practices for Short-term and Permanent Flags