<!DOCTYPE html>
<html lang="en">
  <head>	
    <meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="description" content="Apache Druid">
<meta name="keywords" content="druid,kafka,database,analytics,streaming,real-time,real time,apache,open source">
<meta name="author" content="Apache Software Foundation">

<title>Druid | Powered by Apache Druid</title>
<link rel="canonical" href="https://druid.apache.org/druid-powered" />
<link rel="alternate" type="application/atom+xml" href="/feed">
<link rel="shortcut icon" href="/img/favicon.png">

<link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.7.2/css/all.css" integrity="sha384-fnmOCqbTlWIlj8LyTjo7mOUStjsKC4pOpQbqyi7RrhN7udi9RwhKkMHpvLbHG9Sr" crossorigin="anonymous">

<link href='//fonts.googleapis.com/css?family=Open+Sans+Condensed:300,700,300italic|Open+Sans:300italic,400italic,600italic,400,300,600,700' rel='stylesheet' type='text/css'>

<link rel="stylesheet" href="/css/bootstrap-pure.css?v=1.1">
<link rel="stylesheet" href="/css/base.css?v=1.1">
<link rel="stylesheet" href="/css/header.css?v=1.1">
<link rel="stylesheet" href="/css/footer.css?v=1.1">
<link rel="stylesheet" href="/css/syntax.css?v=1.1">
<link rel="stylesheet" href="/css/docs.css?v=1.1">

<script>
  (function() {
    var cx = '000162378814775985090:molvbm0vggm';
    var gcse = document.createElement('script');
    gcse.type = 'text/javascript';
    gcse.async = true;
    gcse.src = (document.location.protocol == 'https:' ? 'https:' : 'http:') +
        '//cse.google.com/cse.js?cx=' + cx;
    var s = document.getElementsByTagName('script')[0];
    s.parentNode.insertBefore(gcse, s);
  })();
</script>


  </head>
  <body>	
    <!-- Start page_header include -->
<script src="//ajax.googleapis.com/ajax/libs/jquery/2.2.4/jquery.min.js"></script>

<div class="top-navigator">
  <div class="container">
    <div class="left-cont">
      <a class="logo" href="/"><span class="druid-logo"></span></a>
    </div>
    <div class="right-cont">
      <ul class="links">
        <li class=""><a href="/technology">Technology</a></li>
        <li class=""><a href="/use-cases">Use Cases</a></li>
        <li class=" active"><a href="/druid-powered">Powered By</a></li>
        <li class=""><a href="/docs/latest/design/">Docs</a></li>
        <li class=""><a href="/community/">Community</a></li>
        <li class="header-dropdown">
          <a>Apache</a>
          <div class="header-dropdown-menu">
            <a href="https://www.apache.org/" target="_blank">Foundation</a>
            <a href="https://www.apache.org/events/current-event" target="_blank">Events</a>
            <a href="https://www.apache.org/licenses/" target="_blank">License</a>
            <a href="https://www.apache.org/foundation/thanks.html" target="_blank">Thanks</a>
            <a href="https://www.apache.org/security/" target="_blank">Security</a>
            <a href="https://www.apache.org/foundation/sponsorship.html" target="_blank">Sponsorship</a>
          </div>
        </li>
        <li class=" button-link"><a href="/downloads.html">Download</a></li>
      </ul>
    </div>
  </div>
  <div class="action-button menu-icon">
    <span class="fa fa-bars"></span> MENU
  </div>
  <div class="action-button menu-icon-close">
    <span class="fa fa-times"></span> MENU
  </div>
</div>

<script type="text/javascript">
  var $menu = $('.right-cont');
  var $menuIcon = $('.menu-icon');
  var $menuIconClose = $('.menu-icon-close');

  function showMenu() {
    $menu.fadeIn(100);
    $menuIcon.fadeOut(100);
    $menuIconClose.fadeIn(100);
  }

  $menuIcon.click(showMenu);

  function hideMenu() {
    $menu.fadeOut(100);
    $menuIconClose.fadeOut(100);
    $menuIcon.fadeIn(100);
  }

  $menuIconClose.click(hideMenu);

  $(window).resize(function() {
    if ($(window).width() >= 840) {
      $menu.fadeIn(100);
      $menuIcon.fadeOut(100);
      $menuIconClose.fadeOut(100);
    }
    else {
      $menu.fadeOut(100);
      $menuIcon.fadeIn(100);
      $menuIconClose.fadeOut(100);
    }
  });
</script>

<!-- Stop page_header include -->


    <div class="druid-header">
  <div class="container">
    <h1>Powered by Apache Druid</h1>
    <h4><a href="https://github.com/apache/druid-website-src/blob/master/druid-powered.md"><span class="fa fa-plus"></span> Add Your Company</a></h4>
  </div>
</div>

<div class="container">
  <div class="row">
    <div class="col-md-10 col-md-offset-1">
      <p>There are numerous companies of various sizes in production with Druid. Some of them are listed below.</p>

<h2 id="adikteev">Adikteev</h2>

<p><a href="https://www.adikteev.com">Adikteev</a> is the leading mobile app re-engagement platform for performance-driven marketers, and is consistently ranked in the top 5 of the AppsFlyer Performance Index. By using Druid instead of relying on slow and stale dashboards, we have been able to achieve internal productivity gains, make better decisions faster, provide our external clients with strategic advice to improve the performance and effectiveness of their retargeting marketing campaigns, and notify clients quickly of potentially serious problems. </p>

<ul>
<li><a href="https://imply.io/post/how-adikteev-helps-customers-succeed-using-self-service-analytics">How Adikteev helps customers succeed using self-service analytics</a></li>
</ul>

<h2 id="airbnb">Airbnb</h2>

<p>Druid powers slice and dice analytics on both historical and realtime-time metrics. It significantly reduces latency of analytic queries and help people to get insights more interactively.</p>

<ul>
<li><a href="https://medium.com/airbnb-engineering/druid-airbnb-data-platform-601c312f2a4c">How Druid enables analytics at Airbnb</a></li>
</ul>

<h2 id="airbridge">Airbridge</h2>

<p><a href="https://airbridge.io">Airbridge</a> is an people-based attribution and omni-channel campaign analytics platform helping marketers measure and optimize their marketing campaigns. Thanks to Druid&#39;s data aggregation technology, marketers using Airbridge are able to receive real-time granular reports regarding their campaign&#39;s performance executed across a variety of devices, platforms, and channels.</p>

<h2 id="alibaba">Alibaba</h2>

<p>At Alibaba Search Group, we use Druid for real-time analytics of users&#39; interaction with its popular e-commerce site.</p>

<h2 id="allegro">Allegro</h2>

<p><a href="https://allegro.tech/about-us/">Allegro</a> is the most popular Polish shopping destination with about 14 million users monthly and over 1.5 million items sold on the platform daily.
We have been using Druid since 2016 as business intelligence platform to power our clickstream analytics, marketing automation, anomaly detection, technical metrics and more.
Our cluster (432 CPUs, 1300GB of RAM on historicals) processes billions of realtime events loaded from <a href="https://kafka.apache.org/">Kafka</a>
and hundreds batch indexing jobs on daily basis.
It&#39;s a pleasure to work with Druid, extraordinarily efficient and exceptionally stable platform with vibrant community.</p>

<h2 id="amobee">Amobee</h2>

<p>Today’s consumers move across screens with ease. But advertisers and media companies alike struggle to unify audiences and optimize media investment. Only <a href="https://www.amobee.com/">Amobee</a> brings it all together. We give you the power to bridge these silos with end-to-end solutions that help brands, agencies, and media companies optimize the consumer experience across linear TV, connected TV and digital, including social. You are in control, finding the audiences you seek and getting the performance that you need to drive meaningful results for your business. Our loyal customers have achieved dramatic performance improvements and efficiencies by holistically optimizing their full portfolio of media against strategic, in-market audiences. Together, these beloved household brands and premium media providers have made Amobee a world leading advertising &amp; premium media management platform. Why? Like us, they believe that when all media investment can be mapped to business outcomes, everyone wins -- including the consumer.</p>

<p>Amobee provides advertising solutions across tv, digital and social platforms. Amobee has massive incoming data, with customers requiring reporting analytics across unbounded combinations of use cases. Amobee uses Druid to power such intense customer needs via quick response dashboards and offline reports in Amobee’s Platform UI, as well as queries from demanding automated systems. Specifically, we love that Druid allows convergence of many data streams via its robust ingestion, parallel aggregation, redundant storage and concurrent query mechanisms.</p>

<h2 id="apollo-graphql">Apollo GraphQL</h2>

<p>Apollo uses Druid to power our &quot;Graph Manager&quot; SaaS service, which helps application developers manage, validate and secure their organization’s data graph. In addition to managing the evolution of their GraphQL schema, users can draw insights from the operations metadata and execution trace data that are sent to our service, indexed, and stored in Druid.</p>

<h2 id="appsflyer">Appsflyer</h2>

<p>Druid is the major player in the real-time analytics pipeline at Appsflyer, and it serves as customer facing analytics database for dashboard reporting.</p>

<h2 id="archive-it-org">Archive-It.org</h2>

<p>Druid is used to power dynamic analytics and charting in Archive-It Reports. Reports help Archive-It partners understand what content they captured, why some content did not get captured, and assists with quality assurance and crawl scoping to ensure they are building the highest quality collections.</p>

<h2 id="athena-health">Athena Health</h2>

<p>At <a href="https://www.athenahealth.com/">Athena Health</a>, we are creating a new performance management application for our clients, and one of its key components is Apache Druid. </p>

<ul>
<li><a href="https://imply.io/virtual-druid-summit/automating-ci-cd-for-druid-clusters-at-athena-health">Automating CI/CD for Druid Clusters at Athena Health</a></li>
</ul>

<h2 id="atomx">Atomx</h2>

<p>Atomx is a new media exchange that connects networks, DSPs, SSPs, and other parties. Atomx uses Druid for it&#39;s advanced realtime reporting system. Using the Google Cloud modifications Atomx contributed to Druid, it can easily scale Druid with the fast growing platform.</p>

<h2 id="autonomic">Autonomic</h2>

<p>Autonomic Transportation Mobility Cloud (TMC) is the first industry open cloud platform for transportation and mobility data. One of our missions is to enable our customers to easily explore a tremendous amount of data and draw valuable insights in a timely fashion. To meet these needs, we deploy Apache Druid in our platform to aggregate and process time series data. Each component in Druid is running as an individual microservices, and can be easily deployed, managed, and scaled independently in our Kubernetes clusters. </p>

<h2 id="avesta-technologies">Avesta Technologies</h2>

<p>At <a href="https://avestatechnologies.com/">Avesta</a>, we use Druid as a central component in our cloud data platform to provide real-time analytics solutions to our clients. We are using Druid for Customer Data Analytics and extending it for Industrial IoT and Market Automation use cases. Druid has not only proven itself to be resilient and performant but has also helped our clients save enormous amounts in cloud and licensing costs.</p>

<h2 id="bannerflow">Bannerflow</h2>

<p><a href="https://www.bannerflow.com">Bannerflow</a> is the leading display ad production platform. We use Druid to power our customer facing analytics system and for internal reporting, monitoring and ad-hoc data exploration.</p>

<h2 id="bigo">BIGO</h2>

<p>BIGO selects Druid as an OLAP engine to analyze app(Like, Bigolive, IMO, etc.) data in bigdata team. Typical analysis in Druid includes apm, A/B testing, push, funnel model, etc. Besides, Superset is used as dashboard for deep integration with Druid.</p>

<h2 id="billy-mobile">Billy Mobile</h2>

<p>Billy Mobile is a mobile advertising platform, excelling in the performance-based optimisation segment. We use Druid to power our real-time analytics dashboards, in which our publishers, advertisers and staff can get insights on how their campaigns, offers and traffic are performing, with sub-second query time and minute granularity . We are using a lambda-architecture aproach, ingesting the traffic in real time with Tranquility and Storm, and a batch layer via a tight integration with Hive and Hadoop, our Master Data Set. This way we can provide crucial fast access to data, while making sure to have the right numbers.</p>

<h2 id="blis">Blis</h2>

<p><a href="https://www.blis.com">Blis</a> is the trusted leader in location-powered advertising and analytics, helping brands understand, reach and engage consumers globally to deliver measurable results. The operations team uses Druid to manage media purchases and make intelligent pricing decisions. The analytic insights team, which helps customers maximize their value from Blis, uses Druid to discover opportunities and tell data-driven stories about their campaigns. Engineering and product teams use Druid to keep an eye on revenue and margin, with the ability to drill into unexpected changes.</p>

<h2 id="blueshift">Blueshift</h2>

<p>Blueshift is an AI-powered customer data activation platform enabling CRM and product marketers to intelligently manage their audiences and orchestrate large-scale personalized messaging campaigns at scale. Blueshift offers real-time campaign analytics in the product powered by Druid. Additionally, we use the same analytics backend to power automatic traffic allocation capabilities using Bayesian bandits, perform cohort analysis over multiple dimensions, and generate internal reports to measure the impact of ROI of AI across different types of campaigns and industry verticals. </p>

<ul>
<li><a href="https://imply.io/post/blueshift-scaling-real-time-campaign-analytics-apache-druid">We operate a multi-tenant Druid cluster in AWS. Additionally, we have integrated our data lake (Hive/Hbase) with Druid to manage data backfills.</a></li>
</ul>

<h2 id="booking-com">Booking.com</h2>

<ul>
<li><a href="https://www.youtube.com/watch?v=9GE3yiVo1FM">Data Engineering At Booking.com Case Study</a></li>
</ul>

<h2 id="branch">Branch</h2>

<p>Branch uses Druid as their trusted analytics engine to power all of their data analysis needs. This ranges from the user-facing Branch Dashboard analytics that our partners rely on to gain insight into the performance of their links; to the data-driven business decisions that we need to make internally to build a sustainable business.</p>

<h2 id="british-telecom-bt">British Telecom (BT)</h2>

<ul>
<li><a href="https://imply.io/videos/british-telecoms-apache-druid-architecture">British Telecom&#39;s Apache Druid Architecture</a></li>
<li><a href="https://imply.io/videos/why-british-telecom-chose-druid-over-cassandra">Why British Telecom Chose Druid Over Cassandra</a></li>
</ul>

<h2 id="central-bank-of-the-republic-of-turkey">Central Bank of the Republic of Turkey</h2>

<p>The Central Bank of the Republic of Turkey addresses the challenge of analyzing and interpreting real-time tick data related to money market instruments using Apache Druid and Superset.</p>

<ul>
<li><a href="https://www.youtube.com/watch?v=o0JsVwFEdtA">Observing Intraday Indicators Using Real-Time Tick Data on Apache Superset and Druid</a></li>
</ul>

<h2 id="charter-communications">Charter Communications</h2>

<ul>
<li><a href="https://speakerdeck.com/implydatainc/druid-at-charter">Druid at Charter</a></li>
</ul>

<h2 id="circlehd">CircleHD</h2>

<p><a href="https://www.circlehd.com">CircleHD</a> is an enterprise video enablement platform, used by businesses for training, sales enablement and digital learning experience. CircleHD uses Druid to power the analytics system that provides real-time insight into adoption, usage and engagement.</p>

<h2 id="cisco">Cisco</h2>

<p>Cisco uses Druid to power a real-time analytics platform for network flow data.</p>

<ul>
<li><a href="http://www.networkworld.com/article/3086250/cisco-subnet/under-the-hood-of-cisco-s-tetration-analytics-platform.html">Under the hood of Cisco’s Tetration Analytics platform</a></li>
</ul>

<h2 id="cond-nast">Condé Nast</h2>

<p>Condé Nast uses Druid to track billions of events across our two dozen brands, both in real time and historically. Druid helps power dashboards, site performance trackers, and many other internal applications.</p>

<h2 id="confluent">Confluent</h2>

<p>Druid has helped push operational visibility to the next level. Operating multi-tenant services requires fine-grained visibility down to the individual tenant, user, or application behavior, where most traditional monitoring stacks fail to scale or become cost-prohibitive. Leveraging Druid as part of our stack means we don&#39;t shy away from high-cardinality data. As a result, our teams can not only quickly troubleshoot issues but also glean detailed understanding to help improve the product.  </p>

<h2 id="contiamo">Contiamo</h2>

<p><a href="https://www.contiamo.com">Contiamo</a> uses cutting edge technology to enable agile development and deployment of data-driven frontends and automations. Druid powers various dashboards and frontends that deal with large amounts of event based data.</p>

<h2 id="criteo">Criteo</h2>

<p>Criteo is using druid to provide its customers with user-centric analytics &amp; reporting.
With more than 1 billion unique users reached per month, 3 billion ads displayed per day, and a 70% growth in 2014, Criteo&#39;s previous stack was hard pressed keeping with the load. Replacing it with druid helped us achieved linear scalability while letting our customers explore their data in new and interactive ways.</p>

<ul>
<li><a href="http://labs.criteo.com/2016/02/real-time-metrics-on-tracker-calls/">Real Time Metrics on Tracker Calls</a></li>
</ul>

<h2 id="dbs-bank">DBS Bank</h2>

<p><a href="https://www.dbs.com">DBS</a> is using Apache Druid to handle the AML investigation for the compliance team. The AML (anti-money laundering) workflow generates alerts which are tracked within Druid. The transactional data is ingested from RDBMS to S3 and ingested back to Druid at regular intervals. Investigators can now slice and dice over millions of data with low latency.</p>

<ul>
<li><a href="https://imply.io/virtual-druid-summit/apache-druid-anti-money-laundering-dbs-bank">Apache Druid for Anti-Money Laundering (AML) at DBS Bank</a></li>
</ul>

<h2 id="datumo">Datumo</h2>

<p><a href="https://datumo.io/">Datumo</a> is a 100% remote Big Data software house from Poland. 
We are co-authors of <a href="https://allegro.tech/2018/10/turnilo-lets-change-the-way-people-explore-big-data.html">Turnilo</a> - an open-source data exploration tool for Druid. 
Our analytics platform <a href="https://datumo.io/#product">Storyteller</a> uses power of Apache Druid and Turnilo to help our clients analyze large datasets in interactive manner. 
Our biggest Druid deployment is responsible for real-time monitoring and data processing of a large video streaming platform (60 000 Events Per Second).</p>

<h2 id="deep-bi">Deep.BI</h2>

<p>At <a href="https://www.deep.bi">Deep.BI</a> we track user habits, engagement, product and content performance — processing up to terabytes or billions of events of data daily. Our goal is to provide real-time insights based on custom metrics from a variety of self-created dimensions. To accomplish this, our system collects every user interaction. We use Apache Flink for event enrichment, custom transformations, aggregations and serving machine learning models. The processed data is then indexed by Apache Druid for real-time analytics and our custom UI built on top of Druid and Apache Cassandra for delivery of the scores.</p>

<p>Our talk from FlinkForward conference in Berlin 2019:</p>

<ul>
<li><a href="https://medium.com/deep-bi/real-time-stream-analytics-and-user-scoring-using-apache-druid-flink-cassandra-at-deep-bi-38e5dc40958d?source=friends_link&sk=d9c85da0cb060280bfeb8f3c1c166e84">Real-time Stream Analytics and User Scoring Using Apache Druid, Flink &amp; Cassandra at Deep.BI</a></li>
</ul>

<h2 id="delta-projects">Delta Projects</h2>

<p><a href="https://www.deltaprojects.com">Delta Projects</a> uses Druid to power real-time audience and advertising analytics interfaces.</p>

<h2 id="didi-chuxing">Didi Chuxing</h2>

<p>Didi Chuxing is the world’s largest mobile transportation platform, offering a full range of commuting options to 400 cities in China.
Didi uses Druid as a core component of our real-time bigdata processing pipeline. Druid powers Didi&#39;s real-time monitor system which has hundreds of key business metrics. We are deep impressed by Druid&#39;s fast aggregations and sub-second OLAP queries. With Druid, we can get insights from data in real-time.</p>

<h2 id="dream11">Dream11</h2>

<p>Dream11 is consuming data from Apache Druid, Amazon Redshift, and Athena and building models on Looker to report user concurrency, to track user journeys, and to build interaction events based funnels.</p>

<ul>
<li><a href="https://medium.com/@D11Engg/data-highway-dream11s-inhouse-analytics-platform-the-burden-and-benefits-90b8777d282">Data Highway — Dream11’s Inhouse Analytics Platform — The Burden and Benefits</a></li>
</ul>

<h2 id="dripstat">DripStat</h2>

<p>DripStat uses Druid as a timeseries database to power the DripStat GUI. DripStat ingests transactional data for Java, Scala, and Groovy applications into Druid.</p>

<h2 id="easemob">Easemob</h2>

<p>Easemob Technologies, Inc. is the leading provider of open IM platform, cloud computing customer services. We enable PaaS services for Instant Messaging and SaaS services for Mobile Customer Service.</p>

<h2 id="ebay">eBay</h2>

<p>eBay uses Druid to aggregate multiple data streams for real-time user behavior analytics by ingesting up at a very high rate(over 100,000 events/sec), with the ability to query or aggregate data by any random combination of dimensions, and support over 100 concurrent queries without impacting ingest rate and query latencies.</p>

<ul>
<li><a href="https://www.ebayinc.com/stories/blogs/tech/monitoring-at-ebay-with-druid/">Monitoring at eBay with Druid</a></li>
<li><a href="http://blog.csdn.net/ebay/article/details/50205611">Druid and Pulsar</a></li>
<li><a href="http://www.ebaytechblog.com/2016/02/05/embedded-druid-leveraging-druid-capabilities-in-stand-alone-applications/">embedded-druid: Leveraging Druid Capabilities in Stand-alone Applications</a></li>
</ul>

<h2 id="expedia">Expedia</h2>

<p>Expedia built real-time customer segmentation into the Expedia Data Platform using Druid as its core component. It helps business and data science teams identify customers using many different criteria. </p>

<ul>
<li><a href="https://medium.com/expedia-group-tech/fast-approximate-counting-using-druid-and-datasketch-f5f163131acd">Fast Approximate Counting Usind Druid and Datasketch</a></li>
</ul>

<h2 id="facilityconnex">FacilityConneX</h2>

<p>One of our key goals at <a href="https://www.facilityconnex.com/">FacilityConneX</a> is to offer real-time insights that help our customers optimize their equipment or processes, reduce cost, or prevent incidents, to ultimately improve our customers business. This <em>real-time</em> requirement has always been a major technical challenge to scale within our SaaS environment. FacilityConneX has looked to <strong>Druid</strong> to help solve many of these challenging performance and growth issues.</p>

<h2 id="fanatics">Fanatics</h2>

<p>Druid powers our applications related metrics and helps us slice and dice analytics on both historical and realtime-time metrics. It significantly reduces latency of analytic queries and help people to get insights more interactively. Through druid data we can now do anomaly detection as well.</p>

<h2 id="flurry-analytics">Flurry Analytics</h2>

<p><a href="https://www.flurry.com">Flurry</a> is a mobile app analytics platform that empowers product, development and growth experts to build better apps that users love. Mobile data hits the Flurry backend at a huge rate, updates statistics across hundreds of dimensions, and becomes queryable immediately. Flurry harnesses Druid to ingest data and serve queries at this massive rate.</p>

<ul>
<li><a href="https://www.youtube.com/watch?v=6c_hc3Qca5s">Druid @ Flurry</a></li>
</ul>

<h2 id="fullcontact">FullContact</h2>

<ul>
<li><a href="https://www.fullcontact.com/blog/enrich-api-brings-higher-match-rates-with-multi-field-enrichment-capabilities/">Enrich API Brings Higher Match Rates with Multi-Field Enrichment Capabilities</a></li>
</ul>

<h2 id="fyber">Fyber</h2>

<p><a href="https://www.fyber.com">Fyber</a> is an app monetization company, developing a next-generation monetization platform for app game developers. Fyber uses Apache Druid for customer data analysis.</p>

<h2 id="gameanalytics">GameAnalytics</h2>

<ul>
<li><a href="https://imply.io/post/why-gameanalytics-migrated-to-druid">Why GameAnalytics migrated to Apache Druid</a></li>
</ul>

<h2 id="glia">Glia</h2>

<p><a href="https://www.glia.com/">Glia</a> uses Druid to provide application usage insights to its clients.</p>

<h2 id="gumgum">GumGum</h2>

<p>Druid powers a dashboard used internally to visualize real-time analytics on GumGum&#39;s Real Time Bidding platform. GumGum runs Druid on Amazon EC2 and can ingest up to 300,000 events per second at peak time.</p>

<ul>
<li><a href="http://whynosql.com/2015/11/06/lambda-architecture-with-druid-at-gumgum/">Lambda Architecture with Druid at GumGum</a></li>
<li><a href="https://medium.com/gumgum-tech/optimized-real-time-analytics-using-spark-streaming-and-apache-druid-d872a86ed99d">Optimized Real-time Analytics using Spark Streaming and Apache Druid</a></li>
</ul>

<h2 id="hulu">Hulu</h2>

<p>At Hulu, we use Druid to power our analytics platform that enables us to interactively deep dive into the behaviors of our users and applications in real-time.</p>

<h2 id="icsoc-co-ltd">ICSOC Co., Ltd.</h2>

<p><a href="https://www.icsoc.net">ICSOC Co., Ltd.</a> is the leading call center service provider in China. In our big data department, as traditional ways cannot meet our requirements, eventually we found that Druid, designed in lambda, fully satisfies our requires. It simplified developing statistics or real-time products and highly speeded up OLAP queries.</p>

<h2 id="ibotta">Ibotta</h2>

<p><a href="https://home.ibotta.com/">Ibotta</a> is a free cash back rewards and payments app. The company has partnered with more than 1,500 brands and retailers to pay consumers cash for their purchases. Ibotta has paid out over $600 million in cash rewards to more than 35 million users since its founding in 2012.</p>

<ul>
<li><a href="https://imply.io/post/combating-fraud-at-ibotta-with-imply">Combatting fraud at Ibotta with Imply</a></li>
</ul>

<h2 id="imply">Imply</h2>

<p>Imply uses Druid to power public demos and to power our internal monitoring and metrics.</p>

<ul>
<li><a href="https://imply.io/post/hello-pivot">Pivot: An Open Source Data Exploration UI for Druid</a></li>
<li><a href="https://imply.io/post/big-data-zoo">A Tour Through the &quot;Big Data&quot; Zoo</a></li>
<li><a href="https://imply.io/post/failure">Architecting Distributed Databases for Failure</a></li>
<li><a href="http://www.confluent.io/blog/building-a-streaming-analytics-stack-with-apache-kafka-and-druid">Building a Streaming Analytics Stack with Apache Kafka and Druid</a></li>
<li><a href="https://imply.io/post/compressing-longs">Compressing Longs in Druid</a></li>
<li><a href="https://imply.io/post/securing-druid">Securing Druid</a></li>
<li><a href="https://imply.io/post/druid-console-query-view">Druid query view: An elegant SQL interface for a more civilized age</a></li>
</ul>

<h2 id="inke">Inke</h2>

<p><a href="https://www.inke.cn">Inke</a> is a online live company which principally engaged in online live and technology. We use Druid for business intelligence (BI) analytics.</p>

<h2 id="inmobi">Inmobi</h2>

<p>Inmobi is a mobile advertising and discovery platform. We use Druid majorly for internal realtime reporting and analysis. We also use Caravel backed by Druid, which allows users to build interactive dashboards. Apart from that, we use Druid as a Datastore for faster ingestion of large amount of data and to query this data at sub second latencies.</p>

<h2 id="innowatts">Innowatts</h2>

<p>Innowatts uses Druid to quickly work with massive data sets, and differentiates its platform with the intended direction to read meters and forecast usage on the fly.</p>

<ul>
<li><a href="https://imply.io/post/innowatts-innovates-power-utilities-analytics">Innowatts provides AI-driven analytics for the power industry</a></li>
</ul>

<h2 id="interactive-intelligence">Interactive Intelligence</h2>

<p>At ININ we&#39;re using Druid within a Lambda architecture to drive cloud based call center analytics. Many of our realtime dashboards, downloadable reports, and public APIs utilize Druid on the backend.</p>

<h2 id="italiaonline">Italiaonline</h2>

<p>Italiaonline exploits Druid for Internet trends and analytics management inside its new <a href="http://www.italiaonline.it/en/supereva-a-new-online-publishing-experience/">Data-Driven Contents Management System</a>.
Italiaonline is the first Italian internet company, with the two most visited web portals, Libero and Virgilio, and the most used email service of the country @libero.it. Italiaonline features 16.8 million unique users per month&ast;, 4.8 billion impressions per month&ast;&ast;,  10.2 million active email accounts&ast;&ast; and a 58% active reach&ast;.</p>

<p><em>&ast; Source: Audiweb View, powered by Nielsen, TDA 2H 2015; &ast;&ast; Internal data, December 2015</em></p>

<h2 id="jolata">Jolata</h2>

<p>Jolata leverages Druid as the analytics data store for the realtime network perfomance managment platform. Injesting over 35 billion events per day, Jolata calculates a billion metrics every minute to visualize precise network metrics in real-time, and enable operators to quickly drill down and perform root cause analysis.</p>

<ul>
<li><a href="https://www.linkedin.com/pulse/realtime-analytics-powered-druid-kiran-patchigolla">Realtime Analytics Powered by Druid</a></li>
</ul>

<h2 id="kering">Kering</h2>

<p>Thanks to Druid, Kering empowers its sales teams (more than 20,000 people worldwide) to quickly understand their sales performance, compare them to their objectives and identify new sales opportunities within their customer portfolio.<br>
Kering was already providing data on demand via a search engine (Apache Solr), and the implementation of Apache Druid has enabled us to enrich the offer by :
- Adding access to real-time updated KPIs (based on streaming ingestion)
- Providing a sub-second response time
- Offering linear scalability that allows the service to be deployed to tens of thousands of end users
- Allowing massive data updates in a very short period of time (using parquet and mapReduce files) without any impact on the quality of service</p>

<h2 id="kt-nexr">KT NexR</h2>

<p>KT NexR is the leading provider of the data analytics platform. We use Druid as a real-time analysis tool to help our customers to analyze multidimensional data in interactive ways.</p>

<h2 id="ldmobile">LDMobile</h2>

<p>LDMobile is a mobile DSP for the RTB. We use Druid to aggregate some metrics in order to propose to our customers a real-time dashboard showing performance indicators of their campaigns.</p>

<h2 id="lifebuzz">LifeBuzz</h2>

<p>LifeBuzz is a popular web property that serves tens of millions of pageviews per day. We use Druid for all our advanced analytics needs, including in-house analysis and professional realtime analytics for our sponsored media partners.</p>

<h2 id="liquidm">LiquidM</h2>

<p>LiquidM uses Druid for real-time drill-down reporting. LiquidM is also contributing back to the community by creating and maintaining a ruby client library for interacting with Druid located at <a href="http://github.com/liquidm/ruby-druid">http://github.com/liquidm/ruby-druid</a>.</p>

<h2 id="lyft">Lyft</h2>

<ul>
<li><a href="https://youtu.be/ovZ9iAkQllo">Streaming SQL and Druid</a></li>
</ul>

<h2 id="lynx-analytics">Lynx Analytics</h2>

<p><a href="https://www.lynxanalytics.com/">Lynx Analytics</a> helps B2B clients unlock social, behavioral and experience insights
on hundreds of millions of customers. We build interactive dashboards powered by Druid to make the data science
results easy to digest. Our clients love the flexibility and being able to explore the data in detail. The speed at
which they can do that is in a big part thanks to Druid!</p>

<h2 id="makemytrip">MakeMyTrip</h2>

<ul>
<li><a href="https://medium.com/makemytrip-engineering/data-insights-engine-makemytrip-900bd353d99c">Data Insights Engine @ MakeMyTrip</a></li>
</ul>

<h2 id="makesens">MAKESENS</h2>

<p><a href="http://www.battery-doctor.cn/">MAKESENS</a> use Druid to store and analyze battery data.</p>

<h2 id="marchex">Marchex</h2>

<p>Marchex uses Druid to provide data for Marchex Call Analytics&#39; new customer facing Speech Analytics dashboards.
Druid&#39;s fast aggregation is critical for providing deep insights into call performance for its customers,
enabling them to spot trends and improve performance of both marketing campaigns and call centers.</p>

<h2 id="metamarkets">Metamarkets</h2>

<p>Druid is the primary data store for Metamarkets&#39; full stack visual analytics
service for the RTB (real time bidding) space. Ingesting over 200 billion events
per day, Metamarkets is able to provide insight to its customers using complex
ad-hoc queries at a 95th percentile query time of around 1 second.</p>

<h2 id="millersoft">Millersoft</h2>

<p>Druid is the <a href="https://www.millersoft.ltd.uk/">Millersoft</a> platform of choice for operational analytics. The seamless integration of real time and historical data sets within Druid has been a real boon for our data processing clients.
The flexibility of the API via Rest/SQL/Native against a single data source also means that our dashboards, ad-hoc queries and pivot tables are all consistent. The ability to drill down in Druid to the transactions underpinning the aggregations also means that we can reconcile the results directly against operational systems. Druid destroys legacy database cubes at the end of long data integration pipelines.</p>

<h2 id="mindhouse">Mindhouse</h2>

<p>Mindhouse streams data from Apache Kafka into Druid and runs dashboards as well as ad-hoc SQL queries to gain insights from user behavior and pinpoint potential issues in their meditation app.</p>

<ul>
<li><a href="https://imply.io/post/mindhouse-achieves-monitoring-nirvana-with-apache-druid">Mindhouse Achieves Monitoring Nirvana with Apache Druid</a></li>
</ul>

<h2 id="mobiauto">Mobiauto</h2>

<p>Druid has helped Mobiauto ingest and analyze millions of real time events generated on our online car sales website. We use this data to generate real time analytics used by the commercial team, and create APIs for our backend team that can be used to insert real time data to the website that helps our clients make informed decisions.</p>

<h2 id="monetate">Monetate</h2>

<p>Druid is a critical component in Monetate&#39;s personalization platform, where it
acts as the serving layer of a lambda architecture.  As such, Druid powers
numerous real-time dashboards that provide marketers valuable insights into
campaign performance and customer behavior.</p>

<ul>
<li><a href="http://brianoneill.blogspot.com/2015/09/gone-monetate-personalizing-marketing.html">Gone Monetate : Personalizing Marketing at 100K events/second</a></li>
<li><a href="http://brianoneill.blogspot.com/2015/09/druid-vagrant-up-and-tranquility.html">Druid : Vagrant Up (and Tranquility!)</a></li>
<li><a href="http://brianoneill.blogspot.com/2015/09/kinesis-druid-options-analysis-to-push.html">Kinesis -&gt; Druid : Options Analysis (to Push? to Pull? to Firehose? to Nay Nay?)</a></li>
</ul>

<h2 id="mparticle">mParticle</h2>

<p>At <a href="https://www.mparticle.com/">mParticle</a> we have deployed Druid across our entire reporting stack. Druid has enabled us to ingest over 8.5 billion events daily while supporting reliably low latency queries. We have also enabled our support team and customers even greater insight into their data by exposing (controlled) queries to Druid via Looker.</p>

<h2 id="mz">MZ</h2>

<ul>
<li><a href="https://www.youtube.com/watch?v=zCk2BV9mQ0Y">Druid Meetup @ MZ video</a></li>
</ul>

<h2 id="n3twork">N3twork</h2>

<p>N3TWORK uses Druid for real-time analysis of its Internet of Interests social
entertainment network. It uses Druid analytics both to optimize user
experiences and to guide the evolution of its product.</p>

<h2 id="naver">Naver</h2>

<ul>
<li><a href="https://www.slideshare.net/JasonJungsuHEO/web-analytics-at-scale-with-druid-at-navercom">Web Analytics at Scale with Druid</a></li>
</ul>

<h2 id="netflix">Netflix</h2>

<p>Netflix engineers use Druid to aggregate multiple data streams, ingesting up to
two terabytes per hour, with the ability to query data as its being ingested.
They use Druid to pinpoint anomalies within their infrastructure, endpoint
activity and content flow.</p>

<ul>
<li><a href="https://www.youtube.com/watch?v=Qvhqe4yUKpw&feature=youtu.be">Druid Meetup @ Netflix video</a></li>
<li><a href="https://www.slideshare.net/JaebinYoon/druid-meetup-netflix-11142018/">Druid Meetup @ Netflix slides</a></li>
<li><a href="https://aws.amazon.com/solutions/case-studies/netflix-kinesis-streams/">Netflix &amp; Amazon Case Study</a></li>
<li><a href="http://techblog.netflix.com/2013/12/announcing-suro-backbone-of-netflixs.html">Announcing Suro: Backbone of Netflix&#39;s Data Pipeline</a></li>
<li><a href="https://netflixtechblog.com/how-netflix-uses-druid-for-real-time-insights-to-ensure-a-high-quality-experience-19e1e8568d06">How Netflix uses Druid for Real-time Insights to Ensure a High-Quality Experience</a></li>
</ul>

<h2 id="netsil">Netsil</h2>

<p>Netsil is an observability and analytics company for modern cloud applications. The Netsil Application Operations Center (AOC) uses Druid for real-time queries on sharded data along with support for dynamic and multi-valued attributes. The AOC processes live service interactions in large-scale production applications and also stores massive amounts of historical metrics data. Druid was able to support these and several other AOC requirements allowing the AOC to be scalable and fault-tolerant.</p>

<p>You can learn more about the AOC at http://netsil.com/download/</p>

<ul>
<li><a href="https://blog.netsil.com/a-comparison-of-time-series-databases-and-netsils-use-of-druid-db805d471206">A Comparison of Time Series Databases and Netsil’s Use of Druid</a></li>
</ul>

<h2 id="nielsen-nielsen-marketing-cloud">Nielsen (Nielsen Marketing Cloud)</h2>

<p>Nielsen Marketing Cloud uses Druid as it&#39;s core real-time analytics tool to help its clients monitor, test and improve its audience targeting capabilities.  With Druid, Nielsen provides its clients with in-depth consumer insights leveraging world-class Nielsen audience data.</p>

<ul>
<li><a href="https://imply.io/post/nielsen-marketing-audience-analysis">How Nielsen Marketing Cloud Uses Druid for Audience and Marketing Performance Analysis</a></li>
<li><a href="https://youtu.be/MLUhzuQ0DHY">Counting Unique Users in Real-Time: Here’s a Challenge for You! video</a></li>
<li><a href="https://www.slideshare.net/Hadoop_Summit/counting-unique-users-in-realtime-heres-a-challenge-for-you-139142580">Counting Unique Users in Real-Time: Here’s a Challenge for You! slides</a></li>
<li><a href="https://medium.com/nmc-techblog/data-retention-and-deletion-in-apache-druid-74ffd12398a8">Data Retention and Deletion in Apache Druid</a></li>
</ul>

<h2 id="nodex">Nodex</h2>

<p><a href="https://www.nodex.co.uk">Nodex</a> uses Druid in its real time analytics pipeline to deliver insights and analytics across a wide range of recruitment CRM software, Job boards and recruitment career portals. We ingest large amounts of data and needed something capable of real time metrics to offer KPI&#39;s to our clients to allow them to make better business decisions based on actual usage data.</p>

<h2 id="ntt-com">NTT Com</h2>

<ul>
<li><a href="https://imply.io/post/kappa-architecture-at-ntt">Kappa architecture at NTT Com: Building a streaming analytics stack with Druid and Kafka</a></li>
</ul>

<h2 id="ona">Ona</h2>

<p>Ona <a href="https://ona.io">https://ona.io</a> is a software engineering and design firm based in Nairobi, Kenya and Washington, DC. Our mission is to improve the effectiveness of humanitarian and development aid by empowering organizations worldwide with collective and actionable intelligence. We use Druid to power dashboards and disseminate global health and service delivery data pulled from diverse sources.</p>

<h2 id="oneapm">OneAPM</h2>

<p>OneAPM <a href="http://oneapm.com">http://oneapm.com</a> is an IT service compmay focusing on Application Performance Management (APM). In OneAPM, Druid is used to power clients&#39; interactive queries on performance data collected from their applications in realtime.</p>

<h2 id="oppo">Oppo</h2>

<p>Oppo is one of the world largest mobile phone manufacturer. Druid is used to realtime data analyze.</p>

<h2 id="optimizely">Optimizely</h2>

<p>Optimizely uses Druid to power the results dashboard for Optimizely Personalization. Druid enables Optimizely to provide our customers with in-depth, customizable metrics in real time, allowing them to monitor, test and improve their Personalization campaigns with greater ease and flexibility than before.</p>

<ul>
<li><a href="https://medium.com/engineers-optimizely/slicing-and-dicing-data-with-druid-f61cca8a63d2">Slicing and dicing data with druid</a></li>
<li><a href="https://medium.com/engineers-optimizely/the-anatomy-of-a-druid-segment-file-bed89a93af1e">The anatomy of a Druid segment file</a></li>
</ul>

<h2 id="outbrain">Outbrain</h2>

<ul>
<li><a href="https://medium.com/outbrain-engineering/understanding-spark-streaming-with-kafka-and-druid-25b69e28dcb7">Understanding Spark Streaming with Kafka and Druid</a></li>
</ul>

<h2 id="paypal">Paypal</h2>

<p>The Druid production deployment at PayPal processes a very large volume of data
and is used for internal exploratory analytics by business analytic teams. Here
is what they have to say:</p>

<blockquote>
<p>Around early Feb, 2014, the Paypal Tracking Platform team, lead by Suresh Kumar, stumbled upon an article talking about a new
upcoming kid in Real Time Analytics world. After first glance it seemed just like any other
new cool looking technology. But after reading little deeper into the papers(they had
referred) and few blogs, it was clear it is different. The fundamental approach to query
the data itself looked very different and refreshing.</p>

<p>Coincidently, at the same time, the team was struggling to create a very high volume real-time data
query system. We had already explored Drill, Hive, Cassandra, TSDB, Shark etc.
Dating back at least a year, none of these technologies were fulfilling our low latency needs for very high
volumes of data.</p>

<p>So, as an option we started the Druid prototype and within couple of weeks it was looking like
a very promising alternate. Very soon with great help from Core Druid development team
our prototype was doing great.</p>

<p>We then started the prototype with large 7-10 billion records and see the response time for
query. It was quite amazing.</p>

<p>Today our Druid implementation in PayPal processes a very large volume of Data and is
used for our internal exploratory analytics by business analytic teams.</p>

<p>The thing we liked the most was amazing support provided by core Druid team. I have never
seen a Open Source Community providing such a very high level of responsiveness for ANY
issue related to Druid setup and tuning.</p>
</blockquote>

<ul>
<li><a href="https://dataworkssummit.com/san-jose-2018/session/paypal-merchant-ecosystem-using-apache-spark-hive-druid-and-hbase/">PayPal merchant ecosystem using Apache Spark, Hive, Druid, and HBase</a></li>
</ul>

<h2 id="payu">PayU</h2>

<p><a href="https://payu.in">PayU</a> is a payment service provider. We have several services that publish our transactional data into Kafka. We transform the data using Kafka streams and write it flattened and enriched to a different topic. Kafka indexing service then reads the data from the topic and writes it to Druid. We provide dashboards to our merchants that refresh in real-time.</p>

<h2 id="pinterest">Pinterest</h2>

<ul>
<li><a href="https://www.youtube.com/watch?v=LBXtK0DSQIw">Powering Ad Analytics with Apache Druid</a></li>
</ul>

<h2 id="plumbr">Plumbr</h2>

<ul>
<li><a href="https://youtu.be/rx6c7D9QmyU">Introduction to Druid, fast distributed data store</a></li>
<li><a href="https://plumbr.eu/blog/programming/storing-and-querying-trillions-of-events">Storing and accessing trillions of events</a></li>
</ul>

<h2 id="pollfish">Pollfish</h2>

<p>The <a href="https://www.pollfish.com/">Pollfish</a> real-time analytics platform enables researchers to analyze survey data from over half-a-billion consumers across the world, informing advertising, branding, market research, content, and product strategies. Druid is used alongside Apache Kafka, Spark, Flink, Akka Streams, Finatra / Finagle microservices, Cassandra, PostgreSQL, Hive, and Scruid – an open source Scala library for Apache Druid.</p>

<h2 id="poshmark">Poshmark</h2>

<p>Poshmark uses Druid for reporting to monitor key business metrics and data exploration in real-time.</p>

<h2 id="pubnative">PubNative</h2>

<p>PubNative uses Druid for its real-time reports and analysis of millions of daily ad views, clicks, conversions and other events.</p>

<h2 id="quantiply">Quantiply</h2>

<p>Quantiply uses Druid for its feature learning, and governance layer for Compliance and Regulatory (CoRe) platform.</p>

<h2 id="raygun">Raygun</h2>

<p>Raygun is a full stack software intelligence platform that monitors your applications for errors, crashes and performance issues. They use Druid to complete complex queries with large data sets. Having seen similar stories from others, including those who invested in other technologies such as the Hadoop ecosystem or key-value stores, Raygun began researching other more purpose-built analytics databases. Druid happens to be the one they settled on, as it offers several nice properties one wants in an analytics database.</p>

<ul>
<li><a href="https://raygun.com/blog/2016/12/druid-groupby-v2-engine/">Using the Druid GroupBy V2 engine for real-time analytics</a></li>
</ul>

<h2 id="razorpay">Razorpay</h2>

<p>We have successfully deployed Druid at <a href="https://razorpay.com/">Razorpay</a> for our use cases and see continued growth in its footprint. We were able to achieve p90, p95 values of less than 5s and 10s respectively and our dashboard performances have improved by at least 10x when compared to Presto.</p>

<ul>
<li><a href="https://medium.com/@birendra.sahu_77409/how-razorpay-uses-druid-for-seamless-analytics-and-product-insights-364c01b87f1e">How Razorpay uses Druid for seamless analytics and product insights?</a></li>
</ul>

<h2 id="redborder">Redborder</h2>

<p>redBorder is an open source, scale out, cybersecurity analytics platform based on Druid. We hope its full-blown web interface, dashboard and report systems, and ready-to-use real-time pipeline foster other Druid users to create a strong community around it. To see more, please visit redborder.org</p>

<h2 id="reddit">Reddit</h2>

<p>Druid is a critical component in our advertising infrastructure, where it serves as the backend for our external reporting dashboards.</p>

<ul>
<li><a href="https://redditblog.com/2021/02/26/scaling-reporting-at-reddit/">Scaling Reporting at Reddit</a></li>
</ul>

<h2 id="retargetly">Retargetly</h2>

<p>Retargetly is a Data Management Platform that enables publishers and advertisers to manage their first party user data, mix it with second and third party data from others providers and activate it into advertising campaigns (direct, programmatic, etc.). Druid enables us to show real time audience insights. It also provides a lot of flexibility on ad-hoc queries with low latency. We provide default graphs and metrics to our clients but they also have the possibility to make their own interactive queries on real-time.</p>

<h2 id="roambee">Roambee</h2>

<p>We introduced Druid to our technology stack while developing our new supply chain &amp; logistics visibility and intelligence solution. Combining Druid with other data storage, streaming &amp; processing platforms &amp; solutions for the IoT sensor data and 3rd party data helped us design an effective solution for our customers worldwide.</p>

<h2 id="rubicon-project">Rubicon Project</h2>

<p>Rubicon Project is the world’s largest independent sell-side advertising platform that helps premium websites and mobile apps sell ads easily and safely. Rubicon Project’s flagship reporting platform, Performance Analytics, is built on Apache Druid and is used by thousands of companies across the globe. Performance Analytics processed more than two trillion events per day during Black Friday. Druid delivers analytics from this data with an average response times under 600 ms, helping publishers maximize the yield of their digital ad inventory across the open internet and builds on our commitment to trust and transparency in the programmatic marketplace.</p>

<ul>
<li><a href="https://imply.io/post/modernizing-rubicon-projects-analytics-stack">Modernizing Rubicon Project’s Analytics Stack for Programmatic Advertising</a></li>
</ul>

<h2 id="sage-archer">Sage + Archer</h2>

<p>We are using Druid as our single source of truth for both realtime statistics and data analysis. Our clients can see and filter detailed metrics in our <a href="https://www.sage-archer.com">self-service DSP</a>. The DSP is used for mobile and digital-out-of-home advertising campaigns. Druid is powering both the front-end and the optimization algorithms within the system.</p>

<h2 id="salesforce">Salesforce</h2>

<p>Salesforce&#39;s Edge Intelligence team uses Apache Druid as a real-time analytical database to store application performance metrics extracted from log lines. Our customers within Salesforce, including engineers, product owners, customer service representatives, etc., use our service to define the way they want to ingest and query their data and obtain insights such as performance analysis, trend analysis, release comparison, issue triage, and troubleshooting. We chose Druid because it gives us the flexibility to define pre-aggregations, the ability to easily manage ingestion tasks, the ability to query data effectively, and the means to create a highly scalable architecture.</p>

<p><a href="https://engineering.salesforce.com/delivering-high-quality-insights-interactively-using-apache-druid-at-salesforce-7a038f0fe3d1">Delivering High-Quality Insights Interactively Using Apache Druid at Salesforce</a></p>

<h2 id="shopee">Shopee</h2>

<p>At <a href="http://shopee.com/">Shopee</a> Data Engineer Group, we use Druid for real-time analytics of users&#39;(including seller and buyer) interaction with its popular e-commerce site.</p>

<h2 id="sift-science">Sift Science</h2>

<p>Sift Science provides an online trust platform that online businesses use to prevent fraud and abuse. We use Druid as a tool to gain real-time insights about our data and machine learning models.</p>

<h2 id="signoz">SigNoz</h2>

<p><a href="https://signoz.io">SigNoz</a> is an open source observability platform. SigNoz uses distributed tracing to gain visibility into your systems and powers data using Kafka (to handle high ingestion rate and backpressure) and Apache Druid (Apache Druid is a high performance real-time analytics database), both proven in industry to handle scale.</p>

<p>Druid powers aggregations after slicing and dicing of high-dimensional trace data.</p>

<h2 id="sina-weibo">Sina Weibo</h2>

<p>Weibo Advertising Platform deploys Druid as realtime data tool for online advertising analytics and business intelligence(BI). Druid processes TBs of realtime data per day with latency in one minute.</p>

<p>Weibo UVE(Unified Value Evaluation) team of Advertising Platform is using Druid as the realtime analysis tool of the data insight system, which processing billions events everyday.</p>

<h2 id="singular">Singular</h2>

<p>Druid is the primary data store used for ad-hoc analytics in Singular, enabling our customers to generate insights based on real-time and historical data.</p>

<ul>
<li><a href="https://www.singular.net/singular-app-roi-analytics/">How Singular Delivers Blazing Fast App Analytics</a></li>
</ul>

<h2 id="sk-telecom">SK Telecom</h2>

<p>SK Telecom is the leading telecommunication and platform solution company. Druid enable us to discover the business insight interactively from telecommunication, manufacturing big data.</p>

<ul>
<li><a href="https://feathercast.apache.org/2018/09/27/apache-druid-on-kubernetes-elastic-scalable-cloud-based-system-for-real-time-olap-on-high-velocity-data-jinchul-kim-eui-heo/">Apache Druid on Kubernetes: Elastic scalable cloud-based system for real-time OLAP on high velocity data</a></li>
</ul>

<h2 id="skimlinks">Skimlinks</h2>

<p><a href="https://www.skimlinks.com">Skimlinks</a> is the leading commerce content monetization platform. Its technology automatically monetizes product links in commerce-related content.</p>

<h2 id="skyport-systems">Skyport Systems</h2>

<p>Skyport Systems provides zero-effort, low-touch secure servers that help organizations to rapidly deploy and compartmentalize security-critical workloads. We use Druid as part of our analytics backend to provide real-time insight to our customers about their workload behavior.</p>

<h2 id="slack">Slack</h2>

<ul>
<li><a href="https://speakerdeck.com/vananth22/measuring-api-performance-using-druid">Measuring Slack API performance using Druid</a></li>
</ul>

<h2 id="smart-bid">Smart Bid</h2>

<p>Smart Bid is a unique marketing solution platform empowering advertising teams.
A one-stop shop taking advantage of proprietary technology to analyze and reach the right audience with the right creative at the right time. We use Druid to gain real-time insights on real time bidding using our machine learning algorithms.</p>

<h2 id="smyte">Smyte</h2>

<p>Smyte provides an API and UI for detecting and blocking bad actors on the internet. Druid powers the analytics portion of our user interface providing insight into what users are doing on the website, and specifically which features are unique between different sets of users.</p>

<h2 id="snap-inc">Snap, Inc.</h2>

<ul>
<li><a href="https://www.slideshare.net/CharlesAllen9/data-analytics-and-processing-at-snap-druid-meetup-la-september-2018">Data Analytics and Processing at Snap</a></li>
</ul>

<h2 id="societe-generale">Societe Generale</h2>

<p>Societe Generale, one of Europe&#39;s leading financial services groups and a major player in the economy for over 150 years, supports 29 million clients every day with 138,000 staff in 62 countries.</p>

<p>Within the Societe Generale IT department, Apache Druid is used as Time Series Database in order to store performance metrics generated in real-time by thousands of servers, databases, middlewares. These data are stored in multiple Druid clusters in multiple regions (+840 vCPUs, +7000GB of RAM, +300 billions of events) and are used for many purposes, such as dashboarding and predictive maintenance use cases.</p>

<h2 id="splunk">Splunk</h2>

<p>We went through the journey of deploying Apache Druid clusters on Kubernetes and created a <a href="https://github.com/druid-io/druid-operator">druid-operator</a>. We use this operator to deploy Druid clusters at Splunk.</p>

<ul>
<li><a href="https://imply.io/virtual-druid-summit/druid-on-kubernetes-with-druid-operator">Druid on Kubernetes with Druid-operator</a></li>
</ul>

<h2 id="spotx">SpotX</h2>

<ul>
<li><a href="https://www.youtube.com/watch?v=OlmbuyCH4lQ">BelFOSS 2018 SpotX: Hadoop, Spark &amp; Druid</a></li>
</ul>

<h2 id="streamlyzer">Streamlyzer</h2>

<p>Streamlyzer uses Druid as a next generation online video analytics for online video companies or publishers. Streamlyzer is gathering information from real end-users of our customers and provides visualized real-time analytics in dashboard showing how video contents are delivered and how end-users are experiencing the streaming service.</p>

<h2 id="sugo">Sugo</h2>

<p>Sugo is a company that focus on realtime multi-dimension analytics and mining on big data. We build our platform based on Druid, and developed our own extensions to make it more powerful.</p>

<h2 id="superawesome">SuperAwesome</h2>

<p><a href="https://www.superawesome.com">SuperAwesome</a>’s mission is to make the internet safer for kids. At the core of SuperAwesome’s analytics is Apache Druid, which helps us relay key insights and data points back to our stakeholders and customers, as well as use this data to power our products themselves. This all happens in a kid-safe way and enables us to deliver the best level of service to billions of children and teens every month.</p>

<ul>
<li><a href="https://medium.com/superawesome-engineering/how-we-use-apache-druids-real-time-analytics-to-power-kidtech-at-superawesome-8da6a0fb28b1">How we use Apache Druid’s real-time analytics to power kidtech at SuperAwesome</a></li>
<li><a href="https://imply.io/videos/virtual-apache-druid-meetup-featuring-superswesome">Virtual Apache Druid Meetup featuring SuperAwesome</a></li>
</ul>

<h2 id="sweet-couch">Sweet Couch</h2>

<p><a href="https://www.sweetcouch.com">Sweet Couch</a> is a place to discover unique products which are buyable online. Druid powers <a href="https://www.sweetcouch.com/harvest/womens">Sweet Couch harvest</a> which is an open analytics platform for tracking performance of online shops based out in India. All end user events are tracked and analysed using Druid for business insights.</p>

<h2 id="swisscom">Swisscom</h2>

<p>We are providing machine-learning driven, anomaly detection services to our operations teams, using Druid to cover all our storage and query needs. These anomalies currently help engineers during maintenance windows to correct for possible outages before they even happen. Our Dataset includes over 3000 core-network devices and over double that amount in wireless transmission equipment. We ingest and process over 25 million records every minute, but we’re just getting started with onboarding our platforms and services on Druid.</p>

<h2 id="talkingdata">TalkingData</h2>

<p><a href="http://www.talkingdata.com/">TalkingData</a> is China’s largest independent Big Data service platform. TalkingData uses Druid with Atomcube, an extension for enhancement, to power analyze online application and advertising data.</p>

<h2 id="target">Target</h2>

<p>Apache Druid’s speed and flexibility allow us to provide interactive analytics to front-line, edge-of-business consumers to address hundreds of unique use-cases across several business units.</p>

<ul>
<li><a href="https://imply.io/virtual-druid-summit/enterprise-scale-analytics-platform-powered-by-druid-at-target">Enterprise Scale Analytics Platform Powered by Druid at Target</a> </li>
</ul>

<h2 id="tencent">Tencent</h2>

<p>Tencent SCRM product use Druid for customer behavior analysis.</p>

<h2 id="time-warner-cable">Time Warner Cable</h2>

<p>TWC uses Druid for exploratory analytics.</p>

<h2 id="trafficguard">TrafficGuard</h2>

<p>TrafficGuard detects, mitigates and reports on ad fraud before it hits digital advertising budgets. Three formidable layers of protection block both general invalid traffic (GIVT) and sophisticated invalid traffic (SIVT) to ensure that digital advertising results in legitimate advertising engagement. With visibility of traffic across thousands of campaigns, TrafficGuard’s machine learning can identify emerging patterns, trends and indicators of fraud quickly and reliably.</p>

<p>Druid is a key component of our Big Data Operation Insight Platform.We use imply.io
Learn more about TrafficGuard’s comprehensive fraud mitigation at (https://www.trafficguard.ai)</p>

<ul>
<li><a href="https://imply.io/post/using-druid-to-fight-ad-fraud">Using Druid to fight ad fraud</a></li>
</ul>

<h2 id="trendyol-com-alibaba-group-company">Trendyol.com - Alibaba Group Company</h2>

<p>Trendyol, which is the largest e-commerce company in Turkey, uses Druid for real-time analytics. It is mostly used for providing insights to their suppliers.</p>

<h2 id="triplelift">TripleLift</h2>

<p>TripleLift uses Druid to provide insights into performance aspects of its native programmatic exchange for sales/business development opportunities, and to provide reporting used by advertisers and publishers.</p>

<h2 id="truecar">TrueCar</h2>

<p><a href="https://www.truecar.com">TrueCar</a> is a leading automotive digital marketplace that enables car buyers to connect to our nationwide network of Certified Dealers. TrueCar uses Druid and Imply Cloud to help them make their dashboards real-time, detect anomalies, and do so while minimizing engineering and operational overhead. Druid enables TrueCar to unlock insights from digital interaction data, further empowers their data scientists and product teams to improve services with increased agility, and deliver a higher quality experience.</p>

<h2 id="twitch">Twitch</h2>

<p>In order to continue empowering decision making as Twitch scaled, we turned to using Druid and Imply to provide self service analytics to both our technical and non technical staff allowing them to drill into high level metrics in lieu of reading generated reports.</p>

<ul>
<li><a href="https://imply.io/virtual-druid-summit/self-service-analytics-at-twitch">Self Service Analytics at Twitch</a></li>
</ul>

<h2 id="twitter">Twitter</h2>

<ul>
<li><a href="https://blog.twitter.com/engineering/en_us/topics/infrastructure/2019/interactive-analytics-at-mopub.html">Interactive Analytics at MoPub: Querying Terabytes of Data in Seconds</a></li>
</ul>

<h2 id="unity">Unity</h2>

<p>Unity&#39;s monetization business generates billions of in-game events in a multi-sided marketplace, which creates complexity, slowness, and overhead for reporting. To work around these issues, Unity deploys a Kafka, Spark, and Druid-based ingestion and aggregation pipeline.</p>

<ul>
<li><a href="https://medium.com/@linda0511ny/getting-started-with-druid-imply-17d194762574">Getting Started with Druid (Imply)</a></li>
</ul>

<h2 id="verizon">Verizon</h2>

<p>Verizon’s network analytics platform leverages Druid as a real-time analytics engine to enable interactive analytics and performance metrics, support use cases like traffic capacity management using Netflow and network statistics, and provide a feature store for machine learning and service key performance indicators to monitor and quantify the health of Verizon’s global networks. We chose Druid because it enables us to achieve our mission with sub-second latency on large datasets.</p>

<h2 id="videoamp">VideoAmp</h2>

<p>At VideoAmp, Druid is a key component of our Big Data stack. It powers our real-time video advertising analytics at low granularity and huge scale. Druid has helped us minimized the time between event, insight and action.</p>

<h2 id="vigiglobe">Vigiglobe</h2>

<p>Vigiglobe turns the noise of Social Media into real-time Smart Content. To this end, Druid enables us to maintain high request throughput coupled with huge data absorption capacity.</p>

<h2 id="viralgains">ViralGains</h2>

<p>ViralGains uses Druid for real-time analysis of millions of viral video views, shares, and conversations.</p>

<h2 id="virool">Virool</h2>

<p>Druid powers Virool’s real time analytics of over 1 billion raw events per day. We query this data to gain a deep understanding of all of our inventory sources, from exchanges to direct partners, everything is available with lightning fast query times. Druid puts the power and flexibility of big data in each of our Viroolian’s hands.</p>

<h2 id="vserv">Vserv</h2>

<p><a href="https://www.vserv.com">Vserv</a> is the leading authentic data platform for mobile marketing in India. We have successfully implemented Druid for analysis of digital marketing campaign data. </p>

<h2 id="walkme">WalkMe</h2>

<ul>
<li><a href="https://imply.io/post/how-walkme-uses-druid-and-imply-cloud">How WalkMe uses Druid and Imply Cloud to Analyze Clickstreams and User Behavior</a></li>
</ul>

<h2 id="walmart">Walmart</h2>

<ul>
<li><a href="https://medium.com/walmartlabs/event-stream-analytics-at-walmart-with-druid-dcf1a37ceda7">Event Stream Analytics at Walmart with Druid</a></li>
</ul>

<h2 id="weq">WeQ</h2>

<p><a href="http://weq.com">WeQ</a> is a leading mobile performance and branding ad-tech company headquartered in Berlin. Druid is one of the core services that helps WeQ drive user acquisition and engagement to deliver mobile performance and branding campaigns.</p>

<p>We are using Druid for real-time analytics that delivers business insights and power our anti-fraud tools. We are ingesting several billions of events per day using the Kafka real-time connector. Druid is a rock-solid and flexible foundation for our data system delivering blazing-fast analytics</p>

<h2 id="wikimedia-foundation">Wikimedia Foundation</h2>

<p>We&#39;re serving pageview data via Druid and Pivot.  Our internal customers are loving it and we&#39;re working on allowing public access to sanitized data, both editing and pageview.  We like Druid because it&#39;s open source, the folks that work on it have built a good community, and it&#39;s about five times faster than Hive for us right now, without any tuning or optimization (and the Hadoop cluster is beefier than the Druid one), just dumped lots of data into it and Pivot was immediately useful to our analysts.  We wrote a <a href="https://github.com/wikimedia/operations-puppet/tree/production/modules/druid">puppet</a> module that others might find helpful.</p>

<ul>
<li><a href="https://www.oreilly.com/library/view/strata-data-conference/9781491976326/video316954.html">Analytics at Wikipedia</a></li>
<li><a href="https://speakerdeck.com/druidio/analytics-at-wikipedia-with-druid">Analytics at Wikipedia with Druid</a></li>
</ul>

<h2 id="wipro">Wipro</h2>

<p>Wipro Limited is an Indian multinational corporation that provides information technology, consulting and business process services. Wipro is using Druid to track and monitor the performance of internal applications and to gain insights from data in real-time. </p>

<h2 id="xiaomi">Xiaomi</h2>

<p>Xiaomi uses Druid as an analytics tool to analyze online advertising data.</p>

<h2 id="yahoo">Yahoo</h2>

<p>Yahoo uses Druid to power various customer-facing audience and advertising analytics products.</p>

<ul>
<li><a href="https://speakerdeck.com/implydatainc/druid-ecosystem-at-yahoo">Druid Ecosystem at Yahoo</a></li>
<li><a href="http://yahooeng.tumblr.com/post/125287346011/complementing-hadoop-at-yahoo-interactive">Complementing Hadoop at Yahoo: Interactive Analytics with Druid</a></li>
<li><a href="https://yahooeng.tumblr.com/post/147711922956/combining-druid-and-datasketches-for-real-time">Combining Druid and DataSketches for Real-time, Robust Behavioral Analytics</a></li>
</ul>

<h2 id="yeahmobi">YeahMobi</h2>

<p>YeahMobi uses Druid to power a dashboard used for ad-tech analytics such as impression and conversion tracking, unique IP statistics, and aggregating metrics such as costs and revenues.</p>

<h2 id="yieldr">Yieldr</h2>

<p><a href="https://www.yieldr.com">Yieldr</a> uses Druid to power real-time web and mobile analytics for airlines across the globe.</p>

<h2 id="youku-tudou">Youku Tudou</h2>

<p>Youku Tudou employs Druid for real-time advertising analysis of huge volumes of data.</p>

<h2 id="youzan">Youzan</h2>

<p>China Youzan is a SaaS company which principally engaged in retail science and technology. We use Druid for business intelligence (BI) analytics and application performance management (APM) metrics</p>

<h2 id="zapr">Zapr</h2>

<p>Zapr is leveraging Druid to analyze TV viewership data and powering analytical dashboards to report real time user behavior. </p>

<ul>
<li><a href="https://www.meetup.com/Delhi-Apache-Druid-Meetup-Group/events/267001583/">Apache Druid: Sub-second Slice and Dice your Data!</a></li>
</ul>

<h2 id="zeotap">Zeotap</h2>

<ul>
<li><a href="https://imply.io/post/apache-druid-helps-zeotap-master-multi-channel-attribution">Apache Druid helps Zeotap Master Multi-Channel Attribution at Scale</a></li>
</ul>

<h2 id="zhihu">Zhihu</h2>

<p><a href="https://www.zhihu.com/">Zhihu</a> is a Chinese question-and-answer website. In Zhihu, Druid is used to power clients&#39; interactive queries, data reports, A/B testing and performance monitoring. Almost 1T per day data is ingested into druid cluster, and we are strongly depending on thetaSketch aggregator for computing cardinality and retention, looking forward to more improvement on DataSketch.</p>

<h2 id="zilingo">Zilingo</h2>

<p>Zilingo&#39;s data collection infrastructure, processing pipeline and analytics stack is based on Druid. Data is collected from various IOT devices/sensors, mobile and tablet devices and 3p data and is streamed in near realtime. This allows our customers to get a view of the supply chain with thousands of data points via dashboards, reports and the ability to slice and dice data.</p>

<h2 id="zscaler">Zscaler</h2>

<ul>
<li><a href="https://imply.io/post/druid-at-zscaler-security-log-analytics">Druid @ Zscaler - A Retrospective</a></li>
</ul>

<h2 id="zuoyebang">Zuoyebang</h2>

<p><a href="http://www.zuoyebang.com/">Zuoyebang</a> is the most used K12 education platform, 7 out of every 10 K12 users are using Zuoyebang. At Zuoyebang Data Platform Group, we use the Druid in the advertising scene,  mainly related to advertising display, click, billing, and other functions. The performance and timeliness of druid can meet our OLAP queries very well.</p>

<p><a href="https://github.com/apache/druid-website-src/blob/master/druid-powered.md">Add Your Company</a></p>

    </div>
  </div>
</div>

    
    <!-- Start page_footer include -->
<footer class="druid-footer">
<div class="container">
  <div class="text-center">
    <p>
    <a href="/technology">Technology</a>&ensp;·&ensp;
    <a href="/use-cases">Use Cases</a>&ensp;·&ensp;
    <a href="/druid-powered">Powered by Druid</a>&ensp;·&ensp;
    <a href="/docs/latest/">Docs</a>&ensp;·&ensp;
    <a href="/community/">Community</a>&ensp;·&ensp;
    <a href="/downloads.html">Download</a>&ensp;·&ensp;
    <a href="/faq">FAQ</a>
    </p>
  </div>
  <div class="text-center">
    <a title="Join the user group" href="https://groups.google.com/forum/#!forum/druid-user" target="_blank"><span class="fa fa-comments"></span></a>&ensp;·&ensp;
    <a title="Follow Druid" href="https://twitter.com/druidio" target="_blank"><span class="fab fa-twitter"></span></a>&ensp;·&ensp;
    <a title="GitHub" href="https://github.com/apache/druid" target="_blank"><span class="fab fa-github"></span></a>
  </div>
  <div class="text-center license">
    Copyright © 2020 <a href="https://www.apache.org/" target="_blank">Apache Software Foundation</a>.<br>
    Except where otherwise noted, licensed under <a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/">CC BY-SA 4.0</a>.<br>
    Apache Druid, Druid, and the Druid logo are either registered trademarks or trademarks of The Apache Software Foundation in the United States and other countries.
  </div>
</div>
</footer>

<script async src="https://www.googletagmanager.com/gtag/js?id=UA-131010415-1"></script>
<script>
  window.dataLayer = window.dataLayer || [];
  function gtag(){dataLayer.push(arguments);}
  gtag('js', new Date());
  gtag('config', 'UA-131010415-1');
</script>
<script>
  function trackDownload(type, url) {
    ga('send', 'event', 'download', type, url);
  }
</script>
<script src="//code.jquery.com/jquery.min.js"></script>
<script src="//maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js"></script>
<script src="/assets/js/druid.js"></script>
<!-- stop page_footer include -->

    
  </body>
</html>
