<!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="/assets/css/font-awesome-5.css">

<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> (Margot Miller), <em>Imply Blog</em>, 20 Aug 2020.</li>
</ul>

<h2 id="adswizz">AdsWizz</h2>

<p><a href="https://www.adswizz.com/">AdsWizz</a> is the leading global digital audio advertising solution provider, enabling the effective monetization and personalization of digital audio through a complete suite of advertising and analytics solutions. </p>

<p>We use Druid as the core analytics engine, which powers a multitude of real-time dashboards and widgets, used both by customers and internal staff. Sub-second query response times, the removal of obsolete data cubes, ad-hoc analytics and the seamless integration of historical and real-time data are the main reasons we have chosen Druid. Advertisers, agencies and publishers can get insights on hundreds of metrics and dimensions specific to the advertising industry, having the possibility to slice and dice the data according to their needs.</p>

<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><p><a href="https://medium.com/airbnb-engineering/druid-airbnb-data-platform-601c312f2a4c">How Druid enables analytics at Airbnb</a> (Pala Muthiah, Jinyang Li), <em>The AirBnb Tech Blog [Medium]</em>, 13 Nov 2018.</p></li>
<li><p><a href="https://medium.com/airbnb-engineering/how-airbnb-achieved-metric-consistency-at-scale-f23cc53dea70">How Airbnb Achieved Metric Consistency at Scale</a> (Amit Pahwa, Cristian Figueroa, Donghan Zhang, Haim Grosman, John Bodley, Jonathan Parks, Maggie Zhu, Philip Weiss, Robert Chang, Shao Xie, Sylvia Tomiyama, Xiaohui Sun), <em>The AirBnb Tech Blog [Medium]</em>, 30 Apr 2021.</p></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>Druid is widely used in different business units of Alibaba Group.</p>

<ul>
<li><p>At Alibaba Search Group, Druid is used to power real-time analytics of users&#39; interaction with its popular e-commerce site.</p></li>
<li><p>At Alibaba Cloud, Druid powers its <a href="https://www.alibabacloud.com/help/doc-detail/201882.html">E-MapReduce</a> cloud service, which is a big data platform based on open source engines such as Hadoop. See <a href="https://www.alibabacloud.com/help/doc-detail/72987.html">E-MapReduce Druid</a> for more details.</p></li>
<li><p>At its Local Services Business Unit, Druid is responsible for realtime application performance monitoring and alerting. More details can be found in <a href="https://druid.org.cn/?p=91">this blog</a> (Chinese).</p></li>
</ul>

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

<p><a href="https://allegro.tech/">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="alphaa-ai">Alphaa AI</h2>

<p>We leverage Apache Druid in conjunction with the Alphaa AI Super AI NLP Engine to implement Natural Language Query on billions of rows of data for Alphaa Cloud customers.</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://youtu.be/XGzMJBM8xeg">Automating CI/CD for Druid Clusters at Athena Health</a> (Shyam Mudambi, Ramesh Kempanna, Karthik Urs), <em>Imply [YouTube]</em>, 16 Apr 2020.</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>

<ul>
<li><a href="https://imply.io/post/community-spotlight-staying-true-to-open-source-roots-at-avesta">Community Spotlight: staying true to open-source roots at Avesta</a> (Dharam Gajera,Peter Marshall, Jelena Zanko), <em>Imply Blog</em>, 25 May 2021.</li>
</ul>

<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>

<blockquote>
<p>&quot;We operate a multi-tenant Druid cluster in AWS. Additionally, we have integrated our data lake (Hive/Hbase) with Druid to manage data backfills.&quot;</p>
</blockquote>

<ul>
<li><a href="https://imply.io/post/blueshift-scaling-real-time-campaign-analytics-apache-druid">Blueshift: Scaling real-time campaign analytics with Apache Druid</a> (Anuraj Pandey), <em>Imply blog</em>, 8 Aug 2019.</li>
</ul>

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

<ul>
<li><a href="https://youtu.be/9GE3yiVo1FM">Data Engineering At Booking.com: a case study</a> (Andreas Kretz), <em>YouTube</em>, 15 Mar 2019.</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://youtu.be/QZUunUDQ8p4">How Druid powers real-time analytics at BT</a> (Pankaj Tiwari), <em>Imply [YouTube]</em>, 17 Apr 2020.</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://youtu.be/o0JsVwFEdtA">Developing High Frequency Indicators Using Real-Time Tick Data on Apache Superset and Druid</a> (Zekeriya Besiroglu, Emre Tokel, Kerem Başol, M. Yağmur. Şahin), <em>DataWorks Summit [YouTube]</em>, 21 Mar 2019.</li>
</ul>

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

<ul>
<li><a href="https://speakerdeck.com/implydatainc/druid-at-charter">Druid at Charter Spectrum</a> (Nate Vogel, Andy Amick), <em>Imply [SlideShare]</em>, 24 Jan 2019.</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="https://www.networkworld.com/article/3086250/under-the-hood-of-cisco-s-tetration-analytics-platform.html">Under the hood of Cisco’s Tetration Analytics platform</a> (Brandon Butler), <em>Network World</em>, 20 Jun 2016.</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>

<ul>
<li><a href="https://www.confluent.io/blog/scaling-apache-druid-for-real-time-cloud-analytics-at-confluent/">Scaling Apache Druid for Real-Time Cloud Analytics at Confluent</a> (Zohreh Karimi, Harini Rajendran), <em>Confluent Blog</em>, 8 Nov 2021.</li>
</ul>

<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> (Camille Coueslant, Benoit Jehanno), <em>Criteo Engineering</em>, 18 Feb 2016.</li>
</ul>

<h2 id="crunchmetrics">CrunchMetrics</h2>

<p>CrunchMetrics has fully integrated their platform with Apache Druid, designed to quickly ingest massive quantities of event data, and provide low-latency queries on top of the data. With the new integration, customers can gain real-time, intelligent insights from streaming data. This development is in line with the current scalability requirements of 5G and the digital intensification we are all experiencing.</p>

<ul>
<li><a href="https://www.crunchmetrics.ai/blog/crunchmetrics-year-in-review-2020-a-year-that-was-an-anomaly-in-itself/">CrunchMetrics Year in Review 2020: A Year That Was an Anomaly in Itself!</a> (Rohit Maheshwari), <em>CrunchMetrics website</em>, 30 Dec 2020.</li>
</ul>

<h2 id="cuebook">Cuebook</h2>

<p>At <a href="https://cuebook.ai/">Cuebook</a>, Druid serves as the analytics database for our augmented analytics product.</p>

<ul>
<li><a href="https://imply.io/post/augmented-analytics-on-business-metrics-by-cuebook">Augmented analytics on business metrics by Cuebook with Apache Druid</a> (Sachin Bansal, Peter Marshall), <em>Imply blog</em>, 18 Aug 2021.</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://youtu.be/Ly3HFbbEihQ">Holistic AML compliance using Apache Druid</a> (Arpit Dubey), <em>Imply [YouTube]</em>, 15 Apr 2020.</li>
</ul>

<h2 id="dataroid">Dataroid</h2>

<p><a href="https://www.dataroid.com/">Dataroid</a> is a digital analytics and customer engagement platform helping brands to understand their users&#39; interactions with their digital assets in details and deliver a better experience with data-driven insights. </p>

<p>Druid powers Dataroid analytics dashboards allowing our customers to interactively deep dive into behavioral and performance data and explore hundreds of metrics in real time.</p>

<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">Real-time Stream Analytics and User Scoring Using Apache Druid, Flink &amp; Cassandra at Deep.BI</a> (Hisham Itani), <em>Medium</em>, 24 Mar 2020.</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> (Lavanya Pulijala), <em>Dream11 Engineering [Medium]</em>, 27 Jan 2020.</li>
</ul>

<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://tech.ebayinc.com/engineering/monitoring-at-ebay-with-druid/">Monitoring at eBay with Druid</a> (Garadi Mohan), <em>eBay Big Data Engineering</em>, 29 May 2019.</li>
<li><a href="https://tech.ebayinc.com/engineering/embedded-druid-leveraging-druid-capabilities-in-stand-alone-applications/">embedded-druid: Leveraging Druid Capabilities in Stand-alone Applications</a> (Ruchir Shah), <em>eBay Big Data Engineering</em>, 5 Feb 2016.</li>
<li><a href="https://blog.csdn.net/ebay/article/details/50205611">A glance of Pulsar and Druid</a> (Xiaoming Zhang), <em>eBay Big Data Engineering</em>, 7 Dec 2015.</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 Using Druid and Datasketch</a> (Elan Halfin, Aravind Sethurathnam), <em>Expedia Group Technology [Medium]</em>, 10 Dec 2020.</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="finin">Finin</h2>

<p><a href="https://finin.in/">Finin</a> is India’s first ever consumer-facing neobank. They&#39;re using Apache Druid as a backend for analytics, helping the company with clickstream analytics, user activity and behaviour as well as application performance management. </p>

<h2 id="flipkart">Flipkart</h2>

<p>At Flipkart, business and analytics teams need constant visibility into how the users are interacting with the platform across all channels – website, mobile apps and m-site. They are using Druid to power their real-time clickstream analytics reports that enable their business teams to make critical decisions based on current traffic patterns and plan automated as well as manual interventions for traffic shaping.</p>

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

<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://youtu.be/6c_hc3Qca5s">Druid @ Flurry</a> (Eric Tschetter), <em>Sift Science [YouTube]</em>, 16 Dec 2016.</li>
</ul>

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

<ul>
<li><a href="https://www.fullcontact.com/blog/2019/06/27/enrich-api-brings-higher-match-rates-with-multi-field-enrichment-capabilities/">Enrich API Brings Higher Match Rates with Multi-Field Enrichment Capabilities</a> (Ken Michie), <em>Full Contact</em>, 27 Jun 2019.</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> (Ramón Lastres Guerrero), <em>Imply blog</em>, 14 Feb 2019.</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="https://whynosql.com/2015/11/06/lambda-architecture-with-druid-at-gumgum/">Lambda Architecture with Druid at GumGum</a> (Vaibhav Puranik), <em>WhyNoSql [Wordpress]</em>, 6 Nov 2015.</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> (Jatinder Assi), <em>GumGum Tech Blog [Medium]</em>, 2 Jun 2020.</li>
</ul>

<h2 id="hawk">Hawk</h2>

<p><a href="https://hawk-tech.io/">Hawk</a> is the first independent European platform to offer a transparent and technological advertising experience across all screens.</p>

<p>Hawk&#39;s customers harness the power of Imply Druid to access an all-in-one solution to follow their campaign KPIs throughout their lifecycle; build their business dashboards and visualize the evolution of their KPIs; set up tailored reports; and accelerate the Time-To-Market thanks to a simplified data pipeline with Druid directly connected to their Kafka cluster and RDS database.</p>

<ul>
<li><a href="https://imply.io/customer-stories/data-revolution-at-hawk-powered-by-imply/">Data Revolution at Hawk Powered by Imply</a> (Laura Manzanilla), <em>Imply blog</em>, 12 Oct 2021.</li>
</ul>

<h2 id="hexaglobe">Hexaglobe</h2>

<p><a href="https://www.hexaglobe.com/">Hexaglobe</a> uses Druid for network and CDN analytics, and gleans intelligence from video services metrics for engineering and marketing purposes.</p>

<ul>
<li><a href="https://www.youtube.com/watch?v=vooDECOqfy0">How Druid can Help Analyse Video Services Metrics for QoS &amp; Marketing Purposes</a> (Pierre-Alexandre Entraygues, Anthony Courcoux ), <em>Imply [YouTube]</em>, 10 Dec 2021.</li>
</ul>

<h2 id="hubvisor">Hubvisor</h2>

<p>Druid powers <a href="https://www.hubvisor.io/">Hubvisor</a> realtime insights for their customer programmatic advertising auctions.</p>

<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>

<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> (Vadim Ogievetsky), <em>Imply blog</em>, 26 Oct 2015.</li>
<li><a href="https://imply.io/post/big-data-zoo">A Tour Through the &quot;Big Data&quot; Zoo</a> (Fangjin Yang), <em>Imply blog</em>, 4 Nov 2015.</li>
<li><a href="https://imply.io/post/failure">Architecting Distributed Databases for Failure</a> (Fangjin Yang), <em>Imply blog</em>, 10 Dec 2015.</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> (Fangjin Yang), <em>Confluent blog</em>, 14 Jun 2016.</li>
<li><a href="https://imply.io/post/compressing-longs">Compressing Longs in Druid</a> (David Li), <em>Imply blog</em>, 7 Dec 2016.</li>
<li><a href="https://imply.io/post/securing-druid">Securing Druid</a> (Jon Wei), <em>Imply blog</em>, 13 Sep 2018.</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> (Margaret Brewster), <em>Imply blog</em>, 16 Oct 2019.</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">Community Spotlight: Innowatts provides AI-driven analytics for the power industry</a> (Daniel Hernandez, Matt Sarrel), <em>Imply blog</em>, 30 Sep 2020.</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="ironsource">ironSource</h2>

<p>At ironSource, we use Druid to power the real-time capabilities of our in-app bidding solution, which programmatically auctions off publisher ad impressions to a range of ad sources. Using Druid enables us to process and query billions of data points in real time.</p>

<ul>
<li><a href="https://www.youtube.com/watch?v=_co3nPOh7YM">Performance Tuning of Druid Cluster at High Scale</a> (Elad Eldor), <em>Imply [YouTube]</em>, 10 Dec 2021.</li>
</ul>

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

<p>Italiaonline exploits Druid for Internet trends and analytics management inside its new <a href="https://www.italiaonline.it/corporate/en/2016/02/17/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> (Kiran Patchigolla), <em>Medium</em>, 11 Aug 2015.</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="libra-ai-technologies-papergo">Libra AI Technologies &amp; PaperGo</h2>

<p>EMA (Explainable Marketing Analytics) is a marketing analytics assistant powered by Druid. She helps marketeers and ecommerce owners leverage users behavioral data and make data driven decisions. The assistant has been implemented on top of PaperGo loyalty platform and LibraAI proprietary machine learning innovations and marketing analytics.</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="lohika">Lohika</h2>

<p>Lohika uses Druid to run analytics over large amounts of event-based data. They are using real-time ingestion with Apache Kafka to be able to better respond to changes in advertising campaigns. They are managing their cluster with Kubernetes.</p>

<ul>
<li><a href="https://www.lohika.com/apache-druid-interactive-analytics-at-scale">Apache Druid: Interactive Analytics at Scale</a> (Volodymyr Iordanov), <em>Lohika website</em>, 18 May 2021.</li>
</ul>

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

<ul>
<li><a href="https://youtu.be/ovZ9iAkQllo">Streaming SQL and Druid</a> (Arup Malakar), <em>SF Big Analytics [YouTube]</em>, 30 Aug 2018.</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> (Aditya Banerjee), <em>MakeMyTrip [Medium]</em>, 4 Jan 2019.</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>In 2011, Metamarkets originally created Druid to power its SaaS analytics platform.
The technology platform processes trillions of real-time transactions monthly, across thousands of servers.
With Druid, Metamarkets is able to provide insight to its customers using complex ad-hoc queries at a 95th percentile query time of less than 1 second.</p>

<ul>
<li><a href="https://metamarkets.com/2011/druid-part-i-real-time-analytics-at-a-billion-rows-per-second/">Introducing Druid: Real-Time Analytics at a Billion Rows Per Second</a></li>
<li><a href="https://metamarkets.com/2012/scaling-druid/">Scaling the Druid Data Store</a></li>
<li><a href="https://metamarkets.com/2012/metamarkets-open-sources-druid/">Metamarkets Open Sources Druid</a></li>
<li><a href="https://metamarkets.com/2016/impact-on-query-speed-from-forced-processing-ordering-in-druid/">Druid Query Optimization with FIFO: Lessons from Our 5000-Core Cluster</a></li>
<li><a href="https://metamarkets.com/2016/distributing-data-in-druid-at-petabyte-scale/">Distributing Data in Druid at Petabyte Scale</a></li>
</ul>

<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>Priyadarshi, Pushkar; Yurinok, Igor, Nepune, Bikrant. &quot;Druid @ MZ.&quot; <em>YouTube</em>, uploaded by Imply, 5 Mar 2018, <a href="https://youtu.be/zCk2BV9mQ0Y">https://youtu.be/zCk2BV9mQ0Y</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>Merlino, Gian; Herman, Matt; Pasari, Vivek; Jain, Samarth. &quot;Druid @ Netflix&quot;. <em>YouTube</em>, uploaded by Netflix Data, 14 Nov 2018. <a href="https://youtu.be/Qvhqe4yUKpw">https://youtu.be/Qvhqe4yUKpw</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!&quot;</a> (Yakir Buskilla, Itai Yaffe) <em>YouTube</em>, uploaded by DataWorks Summit, 1 Apr 2019.</li>
<li>Buskilla, Yakir; Yaffe, Itai. &quot;Counting Unique Users in Real-Time: Here’s a Challenge for You!&quot; <em>SlideShare</em>, uploaded by DataWorks Summit, 1 Apr 2019. <a href="https://www.slideshare.net/Hadoop_Summit/counting-unique-users-in-realtime-heres-a-challenge-for-you-139142580">https://www.slideshare.net/Hadoop_Summit/counting-unique-users-in-realtime-heres-a-challenge-for-you-139142580</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="noon">Noon</h2>

<p>At Noon – The Social Learning Platform, on a daily basis we process close to 100M audio and sketch samples from more than 80K students to help measure the voice and sketch quality of our online classrooms. We built a real time analytics platform on Apache Druid and Apache Flink to provide realtime feedback on classroom quality &amp; engagement metrics. </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://www.youtube.com/watch?v=HJvuU0CQS44">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="play-games24x7">Play Games24x7</h2>

<p>Play Games24x7 offers multiple casual as well as real money cash games to its users. To maintain a healthy environment for their players, they constantly look out for any elements that could lead to a win by unethical means in the game. They are using Druid to identify those users who follow this set of patterns, and mark them as fraudulent.</p>

<ul>
<li><a href="https://www.youtube.com/watch?v=5RbJL8vHfi0">Real Time, High Concurrency Use Case in Fraud Detection</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="preset">Preset</h2>

<p>Apache Superset was built by Maxime Beauchemin when he was at Airbnb, to visualize data from Apache Druid. Druid enables highly interactive and responsive Superset dashboards, massively shortening the time from question to answer. </p>

<ul>
<li><a href="https://www.youtube.com/watch?v=O0ESEZaZR88">Building Lightning Fast Dashboards Using Apache Druid &amp; Apache Superset</a></li>
</ul>

<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="rill-data">Rill Data</h2>

<p><a href="https://rilldata.com">Rill Data</a> uses Druid to power its truly elastic, fully managed cloud service. 
Rill uses Druid to deliver operational intelligence to business stakeholders with zero DevOps overhead.
Rill&#39;s team operates the first and longest continuously running Druid service.</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="rovio">Rovio</h2>

<p>We use Druid as the low-latency backend for pivot &amp; time-series dashboards. We typically feed data to Druid in daily batches. Data is used at Rovio to continually improve our games and provide incredible experiences for the millions of players who play our games every day.</p>

<ul>
<li><a href="https://medium.com/@Rovio_Tech/unlocking-interactive-dashboards-at-rovio-with-druid-and-spark-40f8fe6a0b05">Unlocking interactive dashboards at Rovio with Druid and Spark</a></li>
</ul>

<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>

<ul>
<li><a href="https://imply.io/post/community-spotlight-smart-advertising-from-sage-archer-apache-druid">Community Spotlight: smart advertising from Sage+Archer + Apache Druid</a></li>
</ul>

<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="scalac">Scalac</h2>

<p>Scalac migrated to Apache Druid and Apache Kafka (from Apache Cassandra and Apache Spark) for their Blockchain Observability application. The analytical dashboard they created is used to visualize the data from different blockchains. It is built on React with Hooks, Redux, Saga on the front side – and Node.js, Apache Druid, and Apache Kafka on the back-end.</p>

<ul>
<li><a href="https://scalac.io/blog/how-we-reduced-costs-and-simplified-solution-by-using-apache-druid/">How We Reduced Costs and Simplified Solution by Using Apache Druid</a> (Adrian Juszczak), <em>Scalac website</em>, 4 Feb 2020.</li>
</ul>

<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>

<ul>
<li><a href="https://mp.weixin.qq.com/s/WFiPDPvxMUi_QVfBDqgVcQ">Apache Druid in Shopee</a>(in Chinese). Published on 2022-01-13 by <a href="https://github.com/yuanlihan">yuanlihan</a>, a contributor of Apache Druid.</li>
</ul>

<h2 id="shopify">Shopify</h2>

<p>Shopify uses Druid, along with Apache Flink and Airflow, to create an interactive analytics platform for realtime sales data with enormous volume and variety.</p>

<ul>
<li><a href="https://www.youtube.com/watch?v=_xluVN75AaE">The Lessons Learnt From Building Star Schema Type-1 Dimensions With Druid Joins in Shopify</a></li>
</ul>

<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>
<li><a href="https://singular-engineering-blog.medium.com/achieving-fast-upserts-for-apache-druid-db6c33fba466">Achieving fast upserts for Apache Druid</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>Sweet Couch was a place to discover unique products which are buyable online. Druid powered Sweet Couch harvest which was an open analytics platform for tracking performance of online shops based out in India. All end user events were 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="tripstack">TripStack</h2>

<p><a href="https://www.tripstack.com/">TripStack</a> uses Druid to help gain business insight into the tens of billions of flight combinations that TripStack processes every day.</p>

<h2 id="triton-digital">Triton Digital</h2>

<p><a href="https://www.tritondigital.com/">Triton Digital</a> is the global technology and services leader to the audio streaming and podcast industry. Operating in more than 80 countries, Triton Digital provides innovative technology that enables broadcasters, podcasters, and online music services to build their audience, maximize their revenue, and streamline their operations. </p>

<p>Triton Digital uses Druid to <a href="https://www.rilldata.com/powering-programmatic-analytics-at-triton-digital">power their programmatic analytics</a> (<em>Rill Data</em>, Oct 2021).</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="trustpilot">Trustpilot</h2>

<p>Trustpilot used Apache Druid to create an interactive application based on D3 that their entire company uses to put real time numbers behind every business decision. They replaced siloed applications built with Looker, Amplitude and others with Druid tp better respond to requests and provide more functionality to their end users.</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><p><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></p></li>
<li><p><a href="https://blog.twitter.com/engineering/en_us/topics/infrastructure/2022/powering-real-time-data-analytics-with-druid-at-twitter">Powering real-time data analytics with Druid at Twitter</a></p></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="whylabs">WhyLabs</h2>

<p><a href="https://whylabs.ai/">WhyLabs</a> is on a mission to build the interface between humans and AI applications. Our Data and AI Observability platform enables teams to monitor all of their ML models, regardless of scale, with zero configuration necessary. Druid allows WhyLabs to combine stream and batch processing to interactively explore and visualize statistically profiled datasets. </p>

<ul>
<li><a href="https://www.youtube.com/watch?v=XV-rFsv9FTc">Migrating Our ML Insights Platform To Druid</a> (Drew Dahlke), <em>Imply [YouTube]</em>, 10 Dec 2021.</li>
</ul>

<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="wiremind">Wiremind</h2>

<p>Wiremind develops solutions for optimizing sold capacity (passenger transportation, airfreight and event/sport ticketing) that blend UX, software and data science.</p>

<p>We process thousands of millions of rows of data to serve our machine learning models and ingest tens of millions of rows by batch indexation each day. We chose Druid because it gives us the ability to query data effectively, the capacity to manage ingesting tasks easily, and the capability to split data for our diverse clients while having a highly scalable architecture for our growth.</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="https://www.zybang.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>
