<!doctype html>
<html lang="en" dir="ltr" class="mdx-wrapper mdx-page plugin-pages plugin-id-default">
<head>
<meta charset="UTF-8">
<meta name="generator" content="Docusaurus v2.4.1">
<title data-rh="true">Powered by Apache Druid | Apache® Druid</title><meta data-rh="true" name="viewport" content="width=device-width,initial-scale=1"><meta data-rh="true" name="twitter:card" content="summary_large_image"><meta data-rh="true" property="og:image" content="https://druid.apache.org/img/druid_nav.png"><meta data-rh="true" name="twitter:image" content="https://druid.apache.org/img/druid_nav.png"><meta data-rh="true" property="og:url" content="https://druid.apache.org/druid-powered"><meta data-rh="true" name="docusaurus_locale" content="en"><meta data-rh="true" name="docusaurus_tag" content="default"><meta data-rh="true" name="docsearch:language" content="en"><meta data-rh="true" name="docsearch:docusaurus_tag" content="default"><meta data-rh="true" property="og:title" content="Powered by Apache Druid | Apache® Druid"><meta data-rh="true" name="description" content="Powered by Apache Druid"><meta data-rh="true" property="og:description" content="Powered by Apache Druid"><link data-rh="true" rel="icon" href="/img/favicon.png"><link data-rh="true" rel="canonical" href="https://druid.apache.org/druid-powered"><link data-rh="true" rel="alternate" href="https://druid.apache.org/druid-powered" hreflang="en"><link data-rh="true" rel="alternate" href="https://druid.apache.org/druid-powered" hreflang="x-default"><link rel="preconnect" href="https://www.google-analytics.com">
<link rel="preconnect" href="https://www.googletagmanager.com">
<script async src="https://www.googletagmanager.com/gtag/js?id=UA-131010415-1"></script>
<script>function gtag(){dataLayer.push(arguments)}window.dataLayer=window.dataLayer||[],gtag("js",new Date),gtag("config","UA-131010415-1",{})</script>




<link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.7.2/css/all.css">
<script src="https://cdnjs.cloudflare.com/ajax/libs/clipboard.js/2.0.4/clipboard.min.js"></script><link rel="stylesheet" href="/assets/css/styles.546f39eb.css">
<link rel="preload" href="/assets/js/runtime~main.4c9a7172.js" as="script">
<link rel="preload" href="/assets/js/main.3a5ab01b.js" as="script">
</head>
<body class="navigation-with-keyboard">
<script>!function(){function t(t){document.documentElement.setAttribute("data-theme",t)}var e=function(){var t=null;try{t=new URLSearchParams(window.location.search).get("docusaurus-theme")}catch(t){}return t}()||function(){var t=null;try{t=localStorage.getItem("theme")}catch(t){}return t}();t(null!==e?e:"light")}()</script><div id="__docusaurus">
<div role="region" aria-label="Skip to main content"><a class="skipToContent_fXgn" href="#__docusaurus_skipToContent_fallback">Skip to main content</a></div><nav aria-label="Main" class="navbar navbar--fixed-top navbar--dark"><div class="navbar__inner"><div class="navbar__items"><button aria-label="Toggle navigation bar" aria-expanded="false" class="navbar__toggle clean-btn" type="button"><svg width="30" height="30" viewBox="0 0 30 30" aria-hidden="true"><path stroke="currentColor" stroke-linecap="round" stroke-miterlimit="10" stroke-width="2" d="M4 7h22M4 15h22M4 23h22"></path></svg></button><a class="navbar__brand" href="/"><div class="navbar__logo"><img src="/img/druid_nav.png" alt="Apache® Druid" class="themedImage_ToTc themedImage--light_HNdA"><img src="/img/druid_nav.png" alt="Apache® Druid" class="themedImage_ToTc themedImage--dark_i4oU"></div></a></div><div class="navbar__items navbar__items--right"><a class="navbar__item navbar__link" href="/technology">Technology</a><a class="navbar__item navbar__link" href="/use-cases">Use Cases</a><a aria-current="page" class="navbar__item navbar__link navbar__link--active" href="/druid-powered">Powered By</a><a class="navbar__item navbar__link" href="/docs/latest/design/">Docs</a><a class="navbar__item navbar__link" href="/community/">Community</a><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Apache®</a><ul class="dropdown__menu"><li><a href="https://www.apache.org/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Foundation<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://apachecon.com/?ref=druid.apache.org" target="_blank" rel="noopener noreferrer" class="dropdown__link">Events<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://www.apache.org/licenses/" target="_blank" rel="noopener noreferrer" class="dropdown__link">License<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://www.apache.org/foundation/thanks.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Thanks<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://www.apache.org/security/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Security<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://www.apache.org/foundation/sponsorship.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Sponsorship<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li></ul></div><a class="navbar__item navbar__link" href="/downloads/">Download</a><div class="searchBox_ZlJk"><div class="navbar__search"><span aria-label="expand searchbar" role="button" class="search-icon" tabindex="0"></span><input type="search" id="search_input_react" placeholder="Loading..." aria-label="Search" class="navbar__search-input search-bar" disabled=""></div></div></div></div><div role="presentation" class="navbar-sidebar__backdrop"></div></nav><div id="__docusaurus_skipToContent_fallback" class="main-wrapper mainWrapper_z2l0"><main class="container container--fluid margin-vert--lg"><div class="row mdxPageWrapper_j9I6"><div class="col col--8"><article><div class="simple-header"><div class="container"><h1>Powered by Apache Druid</h1></div></div><div class="theme-admonition theme-admonition-tip alert alert--success admonition_LlT9"><div class="admonitionHeading_tbUL"><span class="admonitionIcon_kALy"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>tip</div><div class="admonitionContent_S0QG"><a href="https://github.com/apache/druid-website-src/blob/master/src/pages/druid-powered.md" target="_blank" rel="noopener noreferrer"><span class="fa fa-plus"></span> Add your company</a></div></div><p>There are numerous companies of various sizes in production with Druid. Some of them are listed below.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="adikteev">Adikteev<a href="#adikteev" class="hash-link" aria-label="Direct link to Adikteev" title="Direct link to Adikteev">​</a></h2><p><a href="https://www.adikteev.com" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">How Adikteev helps customers succeed using self-service analytics</a> (Margot Miller), <em>Imply Blog</em>, 20 Aug 2020.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="adswizz">AdsWizz<a href="#adswizz" class="hash-link" aria-label="Direct link to AdsWizz" title="Direct link to AdsWizz">​</a></h2><p><a href="https://www.adswizz.com/" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="airbnb">Airbnb<a href="#airbnb" class="hash-link" aria-label="Direct link to Airbnb" title="Direct link to Airbnb">​</a></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" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="airbridge">Airbridge<a href="#airbridge" class="hash-link" aria-label="Direct link to Airbridge" title="Direct link to Airbridge">​</a></h2><p><a href="https://airbridge.io" target="_blank" rel="noopener noreferrer">Airbridge</a> is an people-based attribution and omni-channel campaign analytics platform helping marketers measure and optimize their marketing campaigns. Thanks to Druid&#x27;s data aggregation technology, marketers using Airbridge are able to receive real-time granular reports regarding their campaign&#x27;s performance executed across a variety of devices, platforms, and channels.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="alibaba">Alibaba<a href="#alibaba" class="hash-link" aria-label="Direct link to Alibaba" title="Direct link to Alibaba">​</a></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&#x27; 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" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">this blog</a> (Chinese).</p></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="allegro">Allegro<a href="#allegro" class="hash-link" aria-label="Direct link to Allegro" title="Direct link to Allegro">​</a></h2><p><a href="https://allegro.tech/" target="_blank" rel="noopener noreferrer">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/" target="_blank" rel="noopener noreferrer">Kafka</a>
and hundreds batch indexing jobs on daily basis.
It&#x27;s a pleasure to work with Druid, extraordinarily efficient and exceptionally stable platform with vibrant community.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="alphaa-ai">Alphaa AI<a href="#alphaa-ai" class="hash-link" aria-label="Direct link to Alphaa AI" title="Direct link to Alphaa AI">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="amobee">Amobee<a href="#amobee" class="hash-link" aria-label="Direct link to Amobee" title="Direct link to Amobee">​</a></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/" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="apollo-graphql">Apollo GraphQL<a href="#apollo-graphql" class="hash-link" aria-label="Direct link to Apollo GraphQL" title="Direct link to Apollo GraphQL">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="appsflyer">Appsflyer<a href="#appsflyer" class="hash-link" aria-label="Direct link to Appsflyer" title="Direct link to Appsflyer">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="archive-itorg">Archive-It.org<a href="#archive-itorg" class="hash-link" aria-label="Direct link to Archive-It.org" title="Direct link to Archive-It.org">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="athena-health">Athena Health<a href="#athena-health" class="hash-link" aria-label="Direct link to Athena Health" title="Direct link to Athena Health">​</a></h2><p>At <a href="https://www.athenahealth.com/" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="atomx">Atomx<a href="#atomx" class="hash-link" aria-label="Direct link to Atomx" title="Direct link to Atomx">​</a></h2><p>Atomx is a new media exchange that connects networks, DSPs, SSPs, and other parties. Atomx uses Druid for it&#x27;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 class="anchor anchorWithStickyNavbar_LWe7" id="autonomic">Autonomic<a href="#autonomic" class="hash-link" aria-label="Direct link to Autonomic" title="Direct link to Autonomic">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="avesta-technologies">Avesta Technologies<a href="#avesta-technologies" class="hash-link" aria-label="Direct link to Avesta Technologies" title="Direct link to Avesta Technologies">​</a></h2><p>At <a href="https://avestatechnologies.com/" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="bigo">BIGO<a href="#bigo" class="hash-link" aria-label="Direct link to BIGO" title="Direct link to BIGO">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="billy-mobile">Billy Mobile<a href="#billy-mobile" class="hash-link" aria-label="Direct link to Billy Mobile" title="Direct link to Billy Mobile">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="blis">Blis<a href="#blis" class="hash-link" aria-label="Direct link to Blis" title="Direct link to Blis">​</a></h2><p><a href="https://www.blis.com" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="blueshift">Blueshift<a href="#blueshift" class="hash-link" aria-label="Direct link to Blueshift" title="Direct link to Blueshift">​</a></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" target="_blank" rel="noopener noreferrer">Blueshift: Scaling real-time campaign analytics with Apache Druid</a> (Anuraj Pandey), <em>Imply blog</em>, 8 Aug 2019.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="bookingcom">Booking.com<a href="#bookingcom" class="hash-link" aria-label="Direct link to Booking.com" title="Direct link to Booking.com">​</a></h2><ul><li><a href="https://youtu.be/9GE3yiVo1FM" target="_blank" rel="noopener noreferrer">Data Engineering At Booking.com: a case study</a> (Andreas Kretz), <em>YouTube</em>, 15 Mar 2019.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="branch">Branch<a href="#branch" class="hash-link" aria-label="Direct link to Branch" title="Direct link to Branch">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="british-telecom-bt">British Telecom (BT)<a href="#british-telecom-bt" class="hash-link" aria-label="Direct link to British Telecom (BT)" title="Direct link to British Telecom (BT)">​</a></h2><ul><li><a href="https://youtu.be/QZUunUDQ8p4" target="_blank" rel="noopener noreferrer">How Druid powers real-time analytics at BT</a> (Pankaj Tiwari), <em>Imply <!-- -->[YouTube]</em>, 17 Apr 2020.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="central-bank-of-the-republic-of-turkey">Central Bank of the Republic of Turkey<a href="#central-bank-of-the-republic-of-turkey" class="hash-link" aria-label="Direct link to Central Bank of the Republic of Turkey" title="Direct link to Central Bank of the Republic of Turkey">​</a></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" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="charter-communications">Charter Communications<a href="#charter-communications" class="hash-link" aria-label="Direct link to Charter Communications" title="Direct link to Charter Communications">​</a></h2><ul><li><a href="https://speakerdeck.com/implydatainc/druid-at-charter" target="_blank" rel="noopener noreferrer">Druid at Charter Spectrum</a> (Nate Vogel, Andy Amick), <em>Imply <!-- -->[SlideShare]</em>, 24 Jan 2019.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="circlehd">CircleHD<a href="#circlehd" class="hash-link" aria-label="Direct link to CircleHD" title="Direct link to CircleHD">​</a></h2><p><a href="https://www.circlehd.com" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="cisco">Cisco<a href="#cisco" class="hash-link" aria-label="Direct link to Cisco" title="Direct link to Cisco">​</a></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" target="_blank" rel="noopener noreferrer">Under the hood of Cisco’s Tetration Analytics platform</a> (Brandon Butler), <em>Network World</em>, 20 Jun 2016.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="condé-nast">Condé Nast<a href="#condé-nast" class="hash-link" aria-label="Direct link to Condé Nast" title="Direct link to Condé Nast">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="confluent">Confluent<a href="#confluent" class="hash-link" aria-label="Direct link to Confluent" title="Direct link to Confluent">​</a></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&#x27;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/" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="contiamo">Contiamo<a href="#contiamo" class="hash-link" aria-label="Direct link to Contiamo" title="Direct link to Contiamo">​</a></h2><p><a href="https://www.contiamo.com" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="criteo">Criteo<a href="#criteo" class="hash-link" aria-label="Direct link to Criteo" title="Direct link to Criteo">​</a></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&#x27;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/" target="_blank" rel="noopener noreferrer">Real Time Metrics on Tracker Calls</a> (Camille Coueslant, Benoit Jehanno), <em>Criteo Engineering</em>, 18 Feb 2016.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="crunchmetrics">CrunchMetrics<a href="#crunchmetrics" class="hash-link" aria-label="Direct link to CrunchMetrics" title="Direct link to CrunchMetrics">​</a></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/" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="cuebook">Cuebook<a href="#cuebook" class="hash-link" aria-label="Direct link to Cuebook" title="Direct link to Cuebook">​</a></h2><p>At <a href="https://cuebook.ai/" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="dbs-bank">DBS Bank<a href="#dbs-bank" class="hash-link" aria-label="Direct link to DBS Bank" title="Direct link to DBS Bank">​</a></h2><p><a href="https://www.dbs.com" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">Holistic AML compliance using Apache Druid</a> (Arpit Dubey), <em>Imply <!-- -->[YouTube]</em>, 15 Apr 2020.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="dataroid">Dataroid<a href="#dataroid" class="hash-link" aria-label="Direct link to Dataroid" title="Direct link to Dataroid">​</a></h2><p><a href="https://www.dataroid.com/" target="_blank" rel="noopener noreferrer">Dataroid</a> is a digital analytics and customer engagement platform helping brands to understand their users&#x27; 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 class="anchor anchorWithStickyNavbar_LWe7" id="datumo">Datumo<a href="#datumo" class="hash-link" aria-label="Direct link to Datumo" title="Direct link to Datumo">​</a></h2><p><a href="https://datumo.io/" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">Turnilo</a> - an open-source data exploration tool for Druid.
Our analytics platform <a href="https://datumo.io/#product" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="deepbi">Deep.BI<a href="#deepbi" class="hash-link" aria-label="Direct link to Deep.BI" title="Direct link to Deep.BI">​</a></h2><p>At <a href="https://www.deep.bi" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="deemaagency">Deema.agency<a href="#deemaagency" class="hash-link" aria-label="Direct link to Deema.agency" title="Direct link to Deema.agency">​</a></h2><p>Deema Agency Delivers Results
As a leading digital advertising agency in Iran, we design, run and optimize performance and awareness-based digital campaigns for businesses and help them to achieve their goals. With state of the art programmatic advertising technology, extensive ad network, and advanced advertising platforms, we deliver your brand message to your target audience in Iran in the most effective way .
We are challenging with the intensive data stream realtime for analytics and better experience with data-driven insights.
Druid powers our applications related metrics and helps us slice and dice analytics on both historical and realtime metrics.</p><p><a href="https://deema.agency" target="_blank" rel="noopener noreferrer">Deema.agency</a></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="delta-projects">Delta Projects<a href="#delta-projects" class="hash-link" aria-label="Direct link to Delta Projects" title="Direct link to Delta Projects">​</a></h2><p><a href="https://www.deltaprojects.com" target="_blank" rel="noopener noreferrer">Delta Projects</a> uses Druid to power real-time audience and advertising analytics interfaces.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="didi-chuxing">Didi Chuxing<a href="#didi-chuxing" class="hash-link" aria-label="Direct link to Didi Chuxing" title="Direct link to Didi Chuxing">​</a></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&#x27;s real-time monitor system which has hundreds of key business metrics. We are deep impressed by Druid&#x27;s fast aggregations and sub-second OLAP queries. With Druid, we can get insights from data in real-time.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="dream11">Dream11<a href="#dream11" class="hash-link" aria-label="Direct link to Dream11" title="Direct link to Dream11">​</a></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" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="easemob">Easemob<a href="#easemob" class="hash-link" aria-label="Direct link to Easemob" title="Direct link to Easemob">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="ebay">eBay<a href="#ebay" class="hash-link" aria-label="Direct link to eBay" title="Direct link to eBay">​</a></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/" target="_blank" rel="noopener noreferrer">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/" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">A glance of Pulsar and Druid</a> (Xiaoming Zhang), <em>eBay Big Data Engineering</em>, 7 Dec 2015.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="expedia">Expedia<a href="#expedia" class="hash-link" aria-label="Direct link to Expedia" title="Direct link to Expedia">​</a></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" target="_blank" rel="noopener noreferrer">Fast Approximate Counting Using Druid and Datasketch</a> (Elan Halfin, Aravind Sethurathnam), <em>Expedia Group Technology <!-- -->[Medium]</em>, 10 Dec 2020.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="facilityconnex">FacilityConneX<a href="#facilityconnex" class="hash-link" aria-label="Direct link to FacilityConneX" title="Direct link to FacilityConneX">​</a></h2><p>One of our key goals at <a href="https://www.facilityconnex.com/" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="fanatics">Fanatics<a href="#fanatics" class="hash-link" aria-label="Direct link to Fanatics" title="Direct link to Fanatics">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="finin">Finin<a href="#finin" class="hash-link" aria-label="Direct link to Finin" title="Direct link to Finin">​</a></h2><p><a href="https://finin.in/" target="_blank" rel="noopener noreferrer">Finin</a> is India’s first ever consumer-facing neobank. They&#x27;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 class="anchor anchorWithStickyNavbar_LWe7" id="flipkart">Flipkart<a href="#flipkart" class="hash-link" aria-label="Direct link to Flipkart" title="Direct link to Flipkart">​</a></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" target="_blank" rel="noopener noreferrer">Clickstream Analytics with Apache Druid</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="flurry-analytics">Flurry Analytics<a href="#flurry-analytics" class="hash-link" aria-label="Direct link to Flurry Analytics" title="Direct link to Flurry Analytics">​</a></h2><p><a href="https://www.flurry.com" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">Druid @ Flurry</a> (Eric Tschetter), <em>Sift Science <!-- -->[YouTube]</em>, 16 Dec 2016.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="fullcontact">FullContact<a href="#fullcontact" class="hash-link" aria-label="Direct link to FullContact" title="Direct link to FullContact">​</a></h2><ul><li><a href="https://www.fullcontact.com/blog/2019/06/27/enrich-api-brings-higher-match-rates-with-multi-field-enrichment-capabilities/" target="_blank" rel="noopener noreferrer">Enrich API Brings Higher Match Rates with Multi-Field Enrichment Capabilities</a> (Ken Michie), <em>Full Contact</em>, 27 Jun 2019.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="fyber">Fyber<a href="#fyber" class="hash-link" aria-label="Direct link to Fyber" title="Direct link to Fyber">​</a></h2><p><a href="https://www.fyber.com" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="gameanalytics">GameAnalytics<a href="#gameanalytics" class="hash-link" aria-label="Direct link to GameAnalytics" title="Direct link to GameAnalytics">​</a></h2><ul><li><a href="https://imply.io/post/why-gameanalytics-migrated-to-druid" target="_blank" rel="noopener noreferrer">Why GameAnalytics migrated to Apache Druid</a> (Ramón Lastres Guerrero), <em>Imply blog</em>, 14 Feb 2019.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="glia">Glia<a href="#glia" class="hash-link" aria-label="Direct link to Glia" title="Direct link to Glia">​</a></h2><p><a href="https://www.glia.com/" target="_blank" rel="noopener noreferrer">Glia</a> uses Druid to provide application usage insights to its clients.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="gumgum">GumGum<a href="#gumgum" class="hash-link" aria-label="Direct link to GumGum" title="Direct link to GumGum">​</a></h2><p>Druid powers a dashboard used internally to visualize real-time analytics on GumGum&#x27;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/" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="hawk">Hawk<a href="#hawk" class="hash-link" aria-label="Direct link to Hawk" title="Direct link to Hawk">​</a></h2><p><a href="https://hawk-tech.io/" target="_blank" rel="noopener noreferrer">Hawk</a> is the first independent European platform to offer a transparent and technological advertising experience across all screens.</p><p>Hawk&#x27;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/" target="_blank" rel="noopener noreferrer">Data Revolution at Hawk Powered by Imply</a> (Laura Manzanilla), <em>Imply blog</em>, 12 Oct 2021.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="hexaglobe">Hexaglobe<a href="#hexaglobe" class="hash-link" aria-label="Direct link to Hexaglobe" title="Direct link to Hexaglobe">​</a></h2><p><a href="https://www.hexaglobe.com/" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="hubvisor">Hubvisor<a href="#hubvisor" class="hash-link" aria-label="Direct link to Hubvisor" title="Direct link to Hubvisor">​</a></h2><p>Druid powers <a href="https://www.hubvisor.io/" target="_blank" rel="noopener noreferrer">Hubvisor</a> realtime insights for their customer programmatic advertising auctions.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="hulu">Hulu<a href="#hulu" class="hash-link" aria-label="Direct link to Hulu" title="Direct link to Hulu">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="icsoc-co-ltd">ICSOC Co., Ltd.<a href="#icsoc-co-ltd" class="hash-link" aria-label="Direct link to ICSOC Co., Ltd." title="Direct link to ICSOC Co., Ltd.">​</a></h2><p><a href="https://www.icsoc.net" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="ibotta">Ibotta<a href="#ibotta" class="hash-link" aria-label="Direct link to Ibotta" title="Direct link to Ibotta">​</a></h2><p><a href="https://home.ibotta.com/" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="imply">Imply<a href="#imply" class="hash-link" aria-label="Direct link to Imply" title="Direct link to Imply">​</a></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" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">Compressing Longs in Druid</a> (David Li), <em>Imply blog</em>, 7 Dec 2016.</li><li><a href="https://imply.io/post/securing-druid" target="_blank" rel="noopener noreferrer">Securing Druid</a> (Jon Wei), <em>Imply blog</em>, 13 Sep 2018.</li><li><a href="https://imply.io/post/druid-console-query-view" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="inke">Inke<a href="#inke" class="hash-link" aria-label="Direct link to Inke" title="Direct link to Inke">​</a></h2><p><a href="https://www.inke.cn" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="inmobi">Inmobi<a href="#inmobi" class="hash-link" aria-label="Direct link to Inmobi" title="Direct link to Inmobi">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="innowatts">Innowatts<a href="#innowatts" class="hash-link" aria-label="Direct link to Innowatts" title="Direct link to Innowatts">​</a></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" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="interactive-intelligence">Interactive Intelligence<a href="#interactive-intelligence" class="hash-link" aria-label="Direct link to Interactive Intelligence" title="Direct link to Interactive Intelligence">​</a></h2><p>At ININ we&#x27;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 class="anchor anchorWithStickyNavbar_LWe7" id="ironsource">ironSource<a href="#ironsource" class="hash-link" aria-label="Direct link to ironSource" title="Direct link to ironSource">​</a></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" target="_blank" rel="noopener noreferrer">Performance Tuning of Druid Cluster at High Scale</a> (Elad Eldor), <em>Imply <!-- -->[YouTube]</em>, 10 Dec 2021.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="italiaonline">Italiaonline<a href="#italiaonline" class="hash-link" aria-label="Direct link to Italiaonline" title="Direct link to Italiaonline">​</a></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/" target="_blank" rel="noopener noreferrer">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<!-- -->*<!-- -->, 4.8 billion impressions per month<!-- -->*<!-- -->*<!-- -->,  10.2 million active email accounts<!-- -->*<!-- -->*<!-- --> and a 58% active reach<!-- -->*<!-- -->.</p><p><em>*<!-- --> Source: Audiweb View, powered by Nielsen, TDA 2H 2015; <!-- -->*<!-- -->*<!-- --> Internal data, December 2015</em></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="jolata">Jolata<a href="#jolata" class="hash-link" aria-label="Direct link to Jolata" title="Direct link to Jolata">​</a></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" target="_blank" rel="noopener noreferrer">Realtime Analytics Powered by Druid</a> (Kiran Patchigolla), <em>Medium</em>, 11 Aug 2015.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="kering">Kering<a href="#kering" class="hash-link" aria-label="Direct link to Kering" title="Direct link to Kering">​</a></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 :</p><ul><li>Adding access to real-time updated KPIs (based on streaming ingestion)</li><li>Providing a sub-second response time</li><li>Offering linear scalability that allows the service to be deployed to tens of thousands of end users</li><li>Allowing massive data updates in a very short period of time (using parquet and mapReduce files) without any impact on the quality of service</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="kt-nexr">KT NexR<a href="#kt-nexr" class="hash-link" aria-label="Direct link to KT NexR" title="Direct link to KT NexR">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="ldmobile">LDMobile<a href="#ldmobile" class="hash-link" aria-label="Direct link to LDMobile" title="Direct link to LDMobile">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="libra-ai-technologies--papergo">Libra AI Technologies &amp; PaperGo<a href="#libra-ai-technologies--papergo" class="hash-link" aria-label="Direct link to Libra AI Technologies &amp; PaperGo" title="Direct link to Libra AI Technologies &amp; PaperGo">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="lifebuzz">LifeBuzz<a href="#lifebuzz" class="hash-link" aria-label="Direct link to LifeBuzz" title="Direct link to LifeBuzz">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="liquidm">LiquidM<a href="#liquidm" class="hash-link" aria-label="Direct link to LiquidM" title="Direct link to LiquidM">​</a></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" target="_blank" rel="noopener noreferrer">http://github.com/liquidm/ruby-druid</a>.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="lohika">Lohika<a href="#lohika" class="hash-link" aria-label="Direct link to Lohika" title="Direct link to Lohika">​</a></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" target="_blank" rel="noopener noreferrer">Apache Druid: Interactive Analytics at Scale</a> (Volodymyr Iordanov), <em>Lohika website</em>, 18 May 2021.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="lyft">Lyft<a href="#lyft" class="hash-link" aria-label="Direct link to Lyft" title="Direct link to Lyft">​</a></h2><ul><li><a href="https://youtu.be/ovZ9iAkQllo" target="_blank" rel="noopener noreferrer">Streaming SQL and Druid</a> (Arup Malakar), <em>SF Big Analytics <!-- -->[YouTube]</em>, 30 Aug 2018.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="lynx-analytics">Lynx Analytics<a href="#lynx-analytics" class="hash-link" aria-label="Direct link to Lynx Analytics" title="Direct link to Lynx Analytics">​</a></h2><p><a href="https://www.lynxanalytics.com/" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="makemytrip">MakeMyTrip<a href="#makemytrip" class="hash-link" aria-label="Direct link to MakeMyTrip" title="Direct link to MakeMyTrip">​</a></h2><ul><li><a href="https://medium.com/makemytrip-engineering/data-insights-engine-makemytrip-900bd353d99c" target="_blank" rel="noopener noreferrer">Data Insights Engine @ MakeMyTrip</a> (Aditya Banerjee), <em>MakeMyTrip <!-- -->[Medium]</em>, 4 Jan 2019.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="makesens">MAKESENS<a href="#makesens" class="hash-link" aria-label="Direct link to MAKESENS" title="Direct link to MAKESENS">​</a></h2><p><a href="http://www.battery-doctor.cn/" target="_blank" rel="noopener noreferrer">MAKESENS</a> use Druid to store and analyze battery data.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="marchex">Marchex<a href="#marchex" class="hash-link" aria-label="Direct link to Marchex" title="Direct link to Marchex">​</a></h2><p>Marchex uses Druid to provide data for Marchex Call Analytics&#x27; new customer facing Speech Analytics dashboards.
Druid&#x27;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 class="anchor anchorWithStickyNavbar_LWe7" id="metamarkets">Metamarkets<a href="#metamarkets" class="hash-link" aria-label="Direct link to Metamarkets" title="Direct link to Metamarkets">​</a></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/" target="_blank" rel="noopener noreferrer">Introducing Druid: Real-Time Analytics at a Billion Rows Per Second</a></li><li><a href="https://metamarkets.com/2012/scaling-druid/" target="_blank" rel="noopener noreferrer">Scaling the Druid Data Store</a></li><li><a href="https://metamarkets.com/2012/metamarkets-open-sources-druid/" target="_blank" rel="noopener noreferrer">Metamarkets Open Sources Druid</a></li><li><a href="https://metamarkets.com/2016/impact-on-query-speed-from-forced-processing-ordering-in-druid/" target="_blank" rel="noopener noreferrer">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/" target="_blank" rel="noopener noreferrer">Distributing Data in Druid at Petabyte Scale</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="millersoft">Millersoft<a href="#millersoft" class="hash-link" aria-label="Direct link to Millersoft" title="Direct link to Millersoft">​</a></h2><p>Druid is the <a href="https://www.millersoft.ltd.uk/" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="mindhouse">Mindhouse<a href="#mindhouse" class="hash-link" aria-label="Direct link to Mindhouse" title="Direct link to Mindhouse">​</a></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" target="_blank" rel="noopener noreferrer">Mindhouse Achieves Monitoring Nirvana with Apache Druid</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="mobiauto">Mobiauto<a href="#mobiauto" class="hash-link" aria-label="Direct link to Mobiauto" title="Direct link to Mobiauto">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="monetate">Monetate<a href="#monetate" class="hash-link" aria-label="Direct link to Monetate" title="Direct link to Monetate">​</a></h2><p>Druid is a critical component in Monetate&#x27;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" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">Druid : Vagrant Up (and Tranquility!)</a></li><li><a href="http://brianoneill.blogspot.com/2015/09/kinesis-druid-options-analysis-to-push.html" target="_blank" rel="noopener noreferrer">Kinesis -&gt; Druid : Options Analysis (to Push? to Pull? to Firehose? to Nay Nay?)</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="mparticle">mParticle<a href="#mparticle" class="hash-link" aria-label="Direct link to mParticle" title="Direct link to mParticle">​</a></h2><p>At <a href="https://www.mparticle.com/" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="mz">MZ<a href="#mz" class="hash-link" aria-label="Direct link to MZ" title="Direct link to MZ">​</a></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" target="_blank" rel="noopener noreferrer">https://youtu.be/zCk2BV9mQ0Y</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="n3twork">N3twork<a href="#n3twork" class="hash-link" aria-label="Direct link to N3twork" title="Direct link to N3twork">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="naver">Naver<a href="#naver" class="hash-link" aria-label="Direct link to Naver" title="Direct link to Naver">​</a></h2><ul><li><a href="https://www.slideshare.net/JasonJungsuHEO/web-analytics-at-scale-with-druid-at-navercom" target="_blank" rel="noopener noreferrer">Web Analytics at Scale with Druid</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="netflix">Netflix<a href="#netflix" class="hash-link" aria-label="Direct link to Netflix" title="Direct link to Netflix">​</a></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" target="_blank" rel="noopener noreferrer">https://youtu.be/Qvhqe4yUKpw</a></li><li><a href="https://aws.amazon.com/solutions/case-studies/netflix-kinesis-streams/" target="_blank" rel="noopener noreferrer">Netflix &amp; Amazon Case Study</a></li><li><a href="http://techblog.netflix.com/2013/12/announcing-suro-backbone-of-netflixs.html" target="_blank" rel="noopener noreferrer">Announcing Suro: Backbone of Netflix&#x27;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" target="_blank" rel="noopener noreferrer">How Netflix uses Druid for Real-time Insights to Ensure a High-Quality Experience</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="netsil">Netsil<a href="#netsil" class="hash-link" aria-label="Direct link to Netsil" title="Direct link to Netsil">​</a></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 <a href="http://netsil.com/download/" target="_blank" rel="noopener noreferrer">http://netsil.com/download/</a></p><ul><li><a href="https://blog.netsil.com/a-comparison-of-time-series-databases-and-netsils-use-of-druid-db805d471206" target="_blank" rel="noopener noreferrer">A Comparison of Time Series Databases and Netsil’s Use of Druid</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="nielsen-nielsen-marketing-cloud">Nielsen (Nielsen Marketing Cloud)<a href="#nielsen-nielsen-marketing-cloud" class="hash-link" aria-label="Direct link to Nielsen (Nielsen Marketing Cloud)" title="Direct link to Nielsen (Nielsen Marketing Cloud)">​</a></h2><p>Nielsen Marketing Cloud uses Druid as it&#x27;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" target="_blank" rel="noopener noreferrer">How Nielsen Marketing Cloud Uses Druid for Audience and Marketing Performance Analysis</a></li><li><a href="https://youtu.be/MLUhzuQ0DHY" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">Data Retention and Deletion in Apache Druid</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="nodex">Nodex<a href="#nodex" class="hash-link" aria-label="Direct link to Nodex" title="Direct link to Nodex">​</a></h2><p><a href="https://www.nodex.co.uk/services/recruitment-crm-software" target="_blank" rel="noopener noreferrer">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&#x27;s to our clients to allow them to make better business decisions based on actual usage data.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="noon">Noon<a href="#noon" class="hash-link" aria-label="Direct link to Noon" title="Direct link to Noon">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="ntt-com">NTT Com<a href="#ntt-com" class="hash-link" aria-label="Direct link to NTT Com" title="Direct link to NTT Com">​</a></h2><ul><li><a href="https://imply.io/post/kappa-architecture-at-ntt" target="_blank" rel="noopener noreferrer">Kappa architecture at NTT Com: Building a streaming analytics stack with Druid and Kafka</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="ocean-it">Ocean IT<a href="#ocean-it" class="hash-link" aria-label="Direct link to Ocean IT" title="Direct link to Ocean IT">​</a></h2><p><a href="http://www.ocean-it.co.kr/index/index.do" target="_blank" rel="noopener noreferrer">OCEAN-IT</a> is a company established in S.Korea 2008, and is playing a role in system &amp; database construction, operation in the public IT sector. We have received a service request from Korea Electric Power Corporation (KEPCO), and have been performing system and data purification work. In particular, OCEAN-IT are carrying out the business at the request of KEPCO, collecting real-time sensor databases such as Boiler, Turbine, and Generator as raw data from four power plants in Korea, and refining them for real-time inquiry and analysis. The raw data collected is 40,000 cases per second, which can be estimated to be 1.15 billion cases per day, and these data are implemented to be searchable within 0.1 second of response speed.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="ona">Ona<a href="#ona" class="hash-link" aria-label="Direct link to Ona" title="Direct link to Ona">​</a></h2><p>Ona <a href="https://ona.io" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="oneapm">OneAPM<a href="#oneapm" class="hash-link" aria-label="Direct link to OneAPM" title="Direct link to OneAPM">​</a></h2><p>OneAPM <a href="http://oneapm.com" target="_blank" rel="noopener noreferrer">http://oneapm.com</a> is an IT service compmay focusing on Application Performance Management (APM). In OneAPM, Druid is used to power clients&#x27; interactive queries on performance data collected from their applications in realtime.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="oppo">Oppo<a href="#oppo" class="hash-link" aria-label="Direct link to Oppo" title="Direct link to Oppo">​</a></h2><p>Oppo is one of the world largest mobile phone manufacturer. Druid is used to realtime data analyze.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="optimizely">Optimizely<a href="#optimizely" class="hash-link" aria-label="Direct link to Optimizely" title="Direct link to Optimizely">​</a></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" target="_blank" rel="noopener noreferrer">Slicing and dicing data with druid</a></li><li><a href="https://medium.com/engineers-optimizely/the-anatomy-of-a-druid-segment-file-bed89a93af1e" target="_blank" rel="noopener noreferrer">The anatomy of a Druid segment file</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="outbrain">Outbrain<a href="#outbrain" class="hash-link" aria-label="Direct link to Outbrain" title="Direct link to Outbrain">​</a></h2><ul><li><a href="https://medium.com/outbrain-engineering/understanding-spark-streaming-with-kafka-and-druid-25b69e28dcb7" target="_blank" rel="noopener noreferrer">Understanding Spark Streaming with Kafka and Druid</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="paypal">Paypal<a href="#paypal" class="hash-link" aria-label="Direct link to Paypal" title="Direct link to Paypal">​</a></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" target="_blank" rel="noopener noreferrer">PayPal merchant ecosystem using Apache Spark, Hive, Druid, and HBase</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="payu">PayU<a href="#payu" class="hash-link" aria-label="Direct link to PayU" title="Direct link to PayU">​</a></h2><p><a href="https://payu.in" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="pinterest">Pinterest<a href="#pinterest" class="hash-link" aria-label="Direct link to Pinterest" title="Direct link to Pinterest">​</a></h2><ul><li><a href="https://www.youtube.com/watch?v=LBXtK0DSQIw" target="_blank" rel="noopener noreferrer">Powering Ad Analytics with Apache Druid</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="play-games24x7">Play Games24x7<a href="#play-games24x7" class="hash-link" aria-label="Direct link to Play Games24x7" title="Direct link to Play Games24x7">​</a></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" target="_blank" rel="noopener noreferrer">Real Time, High Concurrency Use Case in Fraud Detection</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="plumbr">Plumbr<a href="#plumbr" class="hash-link" aria-label="Direct link to Plumbr" title="Direct link to Plumbr">​</a></h2><ul><li><a href="https://youtu.be/rx6c7D9QmyU" target="_blank" rel="noopener noreferrer">Introduction to Druid, fast distributed data store</a></li><li><a href="https://plumbr.eu/blog/programming/storing-and-querying-trillions-of-events" target="_blank" rel="noopener noreferrer">Storing and accessing trillions of events</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="pollfish">Pollfish<a href="#pollfish" class="hash-link" aria-label="Direct link to Pollfish" title="Direct link to Pollfish">​</a></h2><p>The <a href="https://www.pollfish.com/" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="poshmark">Poshmark<a href="#poshmark" class="hash-link" aria-label="Direct link to Poshmark" title="Direct link to Poshmark">​</a></h2><p>Poshmark uses Druid for reporting to monitor key business metrics and data exploration in real-time.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="preset">Preset<a href="#preset" class="hash-link" aria-label="Direct link to Preset" title="Direct link to Preset">​</a></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" target="_blank" rel="noopener noreferrer">Building Lightning Fast Dashboards Using Apache Druid &amp; Apache Superset</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="pubnative">PubNative<a href="#pubnative" class="hash-link" aria-label="Direct link to PubNative" title="Direct link to PubNative">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="quantiply">Quantiply<a href="#quantiply" class="hash-link" aria-label="Direct link to Quantiply" title="Direct link to Quantiply">​</a></h2><p>Quantiply uses Druid for its feature learning, and governance layer for Compliance and Regulatory (CoRe) platform.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="raygun">Raygun<a href="#raygun" class="hash-link" aria-label="Direct link to Raygun" title="Direct link to Raygun">​</a></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/" target="_blank" rel="noopener noreferrer">Using the Druid GroupBy V2 engine for real-time analytics</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="razorpay">Razorpay<a href="#razorpay" class="hash-link" aria-label="Direct link to Razorpay" title="Direct link to Razorpay">​</a></h2><p>We have successfully deployed Druid at <a href="https://razorpay.com/" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">How Razorpay uses Druid for seamless analytics and product insights?</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="redborder">Redborder<a href="#redborder" class="hash-link" aria-label="Direct link to Redborder" title="Direct link to Redborder">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="reddit">Reddit<a href="#reddit" class="hash-link" aria-label="Direct link to Reddit" title="Direct link to Reddit">​</a></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/" target="_blank" rel="noopener noreferrer">Scaling Reporting at Reddit</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="retargetly">Retargetly<a href="#retargetly" class="hash-link" aria-label="Direct link to Retargetly" title="Direct link to Retargetly">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="rill-data">Rill Data<a href="#rill-data" class="hash-link" aria-label="Direct link to Rill Data" title="Direct link to Rill Data">​</a></h2><p><a href="https://rilldata.com" target="_blank" rel="noopener noreferrer">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&#x27;s team operates the first and longest continuously running Druid service.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="roambee">Roambee<a href="#roambee" class="hash-link" aria-label="Direct link to Roambee" title="Direct link to Roambee">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="rovio">Rovio<a href="#rovio" class="hash-link" aria-label="Direct link to Rovio" title="Direct link to Rovio">​</a></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" target="_blank" rel="noopener noreferrer">Unlocking interactive dashboards at Rovio with Druid and Spark</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="rubicon-project">Rubicon Project<a href="#rubicon-project" class="hash-link" aria-label="Direct link to Rubicon Project" title="Direct link to Rubicon Project">​</a></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" target="_blank" rel="noopener noreferrer">Modernizing Rubicon Project’s Analytics Stack for Programmatic Advertising</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="sage--archer">Sage + Archer<a href="#sage--archer" class="hash-link" aria-label="Direct link to Sage + Archer" title="Direct link to Sage + Archer">​</a></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" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">Community Spotlight: smart advertising from Sage+Archer + Apache Druid</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="salesforce">Salesforce<a href="#salesforce" class="hash-link" aria-label="Direct link to Salesforce" title="Direct link to Salesforce">​</a></h2><p>Salesforce&#x27;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" target="_blank" rel="noopener noreferrer">Delivering High-Quality Insights Interactively Using Apache Druid at Salesforce</a></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="scalac">Scalac<a href="#scalac" class="hash-link" aria-label="Direct link to Scalac" title="Direct link to Scalac">​</a></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/" target="_blank" rel="noopener noreferrer">How We Reduced Costs and Simplified Solution by Using Apache Druid</a> (Adrian Juszczak), <em>Scalac website</em>, 4 Feb 2020.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="shopee">Shopee<a href="#shopee" class="hash-link" aria-label="Direct link to Shopee" title="Direct link to Shopee">​</a></h2><p>At <a href="http://shopee.com/" target="_blank" rel="noopener noreferrer">Shopee</a> Data Engineer Group, we use Druid for real-time analytics of users&#x27;(including seller and buyer) interaction with its popular e-commerce site.</p><ul><li><a href="https://mp.weixin.qq.com/s/WFiPDPvxMUi_QVfBDqgVcQ" target="_blank" rel="noopener noreferrer">Apache Druid in Shopee</a>(in Chinese). Published on 2022-01-13 by <a href="https://github.com/yuanlihan" target="_blank" rel="noopener noreferrer">yuanlihan</a>, a contributor of Apache Druid.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="shopify">Shopify<a href="#shopify" class="hash-link" aria-label="Direct link to Shopify" title="Direct link to Shopify">​</a></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" target="_blank" rel="noopener noreferrer">The Lessons Learnt From Building Star Schema Type-1 Dimensions With Druid Joins in Shopify</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="sift-science">Sift Science<a href="#sift-science" class="hash-link" aria-label="Direct link to Sift Science" title="Direct link to Sift Science">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="signoz">SigNoz<a href="#signoz" class="hash-link" aria-label="Direct link to SigNoz" title="Direct link to SigNoz">​</a></h2><p><a href="https://signoz.io" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="sina-weibo">Sina Weibo<a href="#sina-weibo" class="hash-link" aria-label="Direct link to Sina Weibo" title="Direct link to Sina Weibo">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="singular">Singular<a href="#singular" class="hash-link" aria-label="Direct link to Singular" title="Direct link to Singular">​</a></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/" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">Achieving fast upserts for Apache Druid</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="sk-telecom">SK Telecom<a href="#sk-telecom" class="hash-link" aria-label="Direct link to SK Telecom" title="Direct link to SK Telecom">​</a></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/" target="_blank" rel="noopener noreferrer">Apache Druid on Kubernetes: Elastic scalable cloud-based system for real-time OLAP on high velocity data</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="skimlinks">Skimlinks<a href="#skimlinks" class="hash-link" aria-label="Direct link to Skimlinks" title="Direct link to Skimlinks">​</a></h2><p><a href="https://www.skimlinks.com" target="_blank" rel="noopener noreferrer">Skimlinks</a> is the leading commerce content monetization platform. Its technology automatically monetizes product links in commerce-related content.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="skyport-systems">Skyport Systems<a href="#skyport-systems" class="hash-link" aria-label="Direct link to Skyport Systems" title="Direct link to Skyport Systems">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="slack">Slack<a href="#slack" class="hash-link" aria-label="Direct link to Slack" title="Direct link to Slack">​</a></h2><ul><li><a href="https://speakerdeck.com/vananth22/measuring-api-performance-using-druid" target="_blank" rel="noopener noreferrer">Measuring Slack API performance using Druid</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="smart-bid">Smart Bid<a href="#smart-bid" class="hash-link" aria-label="Direct link to Smart Bid" title="Direct link to Smart Bid">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="smyte">Smyte<a href="#smyte" class="hash-link" aria-label="Direct link to Smyte" title="Direct link to Smyte">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="snap-inc">Snap, Inc.<a href="#snap-inc" class="hash-link" aria-label="Direct link to Snap, Inc." title="Direct link to Snap, Inc.">​</a></h2><ul><li><a href="https://www.slideshare.net/CharlesAllen9/data-analytics-and-processing-at-snap-druid-meetup-la-september-2018" target="_blank" rel="noopener noreferrer">Data Analytics and Processing at Snap</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="societe-generale">Societe Generale<a href="#societe-generale" class="hash-link" aria-label="Direct link to Societe Generale" title="Direct link to Societe Generale">​</a></h2><p>Societe Generale, one of Europe&#x27;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 class="anchor anchorWithStickyNavbar_LWe7" id="splunk">Splunk<a href="#splunk" class="hash-link" aria-label="Direct link to Splunk" title="Direct link to Splunk">​</a></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" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">Druid on Kubernetes with Druid-operator</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="spotx">SpotX<a href="#spotx" class="hash-link" aria-label="Direct link to SpotX" title="Direct link to SpotX">​</a></h2><ul><li><a href="https://www.youtube.com/watch?v=OlmbuyCH4lQ" target="_blank" rel="noopener noreferrer">BelFOSS 2018 SpotX: Hadoop, Spark &amp; Druid</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="streamlyzer">Streamlyzer<a href="#streamlyzer" class="hash-link" aria-label="Direct link to Streamlyzer" title="Direct link to Streamlyzer">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="sugo">Sugo<a href="#sugo" class="hash-link" aria-label="Direct link to Sugo" title="Direct link to Sugo">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="superawesome">SuperAwesome<a href="#superawesome" class="hash-link" aria-label="Direct link to SuperAwesome" title="Direct link to SuperAwesome">​</a></h2><p><a href="https://www.superawesome.com" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">Virtual Apache Druid Meetup featuring SuperAwesome</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="sweet-couch">Sweet Couch<a href="#sweet-couch" class="hash-link" aria-label="Direct link to Sweet Couch" title="Direct link to Sweet Couch">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="swisscom">Swisscom<a href="#swisscom" class="hash-link" aria-label="Direct link to Swisscom" title="Direct link to Swisscom">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="talkingdata">TalkingData<a href="#talkingdata" class="hash-link" aria-label="Direct link to TalkingData" title="Direct link to TalkingData">​</a></h2><p><a href="http://www.talkingdata.com/" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="target">Target<a href="#target" class="hash-link" aria-label="Direct link to Target" title="Direct link to Target">​</a></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" target="_blank" rel="noopener noreferrer">Enterprise Scale Analytics Platform Powered by Druid at Target</a> </li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="telemetrydeck-analytics">TelemetryDeck Analytics<a href="#telemetrydeck-analytics" class="hash-link" aria-label="Direct link to TelemetryDeck Analytics" title="Direct link to TelemetryDeck Analytics">​</a></h2><p><a href="https://telemetrydeck.com" target="_blank" rel="noopener noreferrer">TelemetryDeck</a> helps app and web developers improve their product by supplying immediate, accurate usage data while users use their app. And the best part: It&#x27;s all anonymized so users&#x27; data stays private!</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="tencent">Tencent<a href="#tencent" class="hash-link" aria-label="Direct link to Tencent" title="Direct link to Tencent">​</a></h2><p>Tencent SCRM product use Druid for customer behavior analysis.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="time-warner-cable">Time Warner Cable<a href="#time-warner-cable" class="hash-link" aria-label="Direct link to Time Warner Cable" title="Direct link to Time Warner Cable">​</a></h2><p>TWC uses Druid for exploratory analytics.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="trafficguard">TrafficGuard<a href="#trafficguard" class="hash-link" aria-label="Direct link to TrafficGuard" title="Direct link to TrafficGuard">​</a></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 (<a href="https://www.trafficguard.ai" target="_blank" rel="noopener noreferrer">https://www.trafficguard.ai</a>)</p><ul><li><a href="https://imply.io/post/using-druid-to-fight-ad-fraud" target="_blank" rel="noopener noreferrer">Using Druid to fight ad fraud</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="trendyolcom---alibaba-group-company">Trendyol.com - Alibaba Group Company<a href="#trendyolcom---alibaba-group-company" class="hash-link" aria-label="Direct link to Trendyol.com - Alibaba Group Company" title="Direct link to Trendyol.com - Alibaba Group Company">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="triplelift">TripleLift<a href="#triplelift" class="hash-link" aria-label="Direct link to TripleLift" title="Direct link to TripleLift">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="tripstack">TripStack<a href="#tripstack" class="hash-link" aria-label="Direct link to TripStack" title="Direct link to TripStack">​</a></h2><p><a href="https://www.tripstack.com/" target="_blank" rel="noopener noreferrer">TripStack</a> uses Druid to help gain business insight into the tens of billions of flight combinations that TripStack processes every day.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="triton-digital">Triton Digital<a href="#triton-digital" class="hash-link" aria-label="Direct link to Triton Digital" title="Direct link to Triton Digital">​</a></h2><p><a href="https://www.tritondigital.com/" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">power their programmatic analytics</a> (<em>Rill Data</em>, Oct 2021).</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="truecar">TrueCar<a href="#truecar" class="hash-link" aria-label="Direct link to TrueCar" title="Direct link to TrueCar">​</a></h2><p><a href="https://www.truecar.com" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="trustpilot">Trustpilot<a href="#trustpilot" class="hash-link" aria-label="Direct link to Trustpilot" title="Direct link to Trustpilot">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="twitch">Twitch<a href="#twitch" class="hash-link" aria-label="Direct link to Twitch" title="Direct link to Twitch">​</a></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" target="_blank" rel="noopener noreferrer">Self Service Analytics at Twitch</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="twitter">Twitter<a href="#twitter" class="hash-link" aria-label="Direct link to Twitter" title="Direct link to Twitter">​</a></h2><ul><li><p><a href="https://blog.twitter.com/engineering/en_us/topics/infrastructure/2019/interactive-analytics-at-mopub.html" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">Powering real-time data analytics with Druid at Twitter</a></p></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="unity">Unity<a href="#unity" class="hash-link" aria-label="Direct link to Unity" title="Direct link to Unity">​</a></h2><p>Unity&#x27;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" target="_blank" rel="noopener noreferrer">Getting Started with Druid (Imply)</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="verizon">Verizon<a href="#verizon" class="hash-link" aria-label="Direct link to Verizon" title="Direct link to Verizon">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="videoamp">VideoAmp<a href="#videoamp" class="hash-link" aria-label="Direct link to VideoAmp" title="Direct link to VideoAmp">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="vigiglobe">Vigiglobe<a href="#vigiglobe" class="hash-link" aria-label="Direct link to Vigiglobe" title="Direct link to Vigiglobe">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="viralgains">ViralGains<a href="#viralgains" class="hash-link" aria-label="Direct link to ViralGains" title="Direct link to ViralGains">​</a></h2><p>ViralGains uses Druid for real-time analysis of millions of viral video views, shares, and conversations.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="virool">Virool<a href="#virool" class="hash-link" aria-label="Direct link to Virool" title="Direct link to Virool">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="vserv">Vserv<a href="#vserv" class="hash-link" aria-label="Direct link to Vserv" title="Direct link to Vserv">​</a></h2><p><a href="https://www.vserv.com" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="walkme">WalkMe<a href="#walkme" class="hash-link" aria-label="Direct link to WalkMe" title="Direct link to WalkMe">​</a></h2><ul><li><a href="https://imply.io/post/how-walkme-uses-druid-and-imply-cloud" target="_blank" rel="noopener noreferrer">How WalkMe uses Druid and Imply Cloud to Analyze Clickstreams and User Behavior</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="walmart">Walmart<a href="#walmart" class="hash-link" aria-label="Direct link to Walmart" title="Direct link to Walmart">​</a></h2><ul><li><a href="https://medium.com/walmartlabs/event-stream-analytics-at-walmart-with-druid-dcf1a37ceda7" target="_blank" rel="noopener noreferrer">Event Stream Analytics at Walmart with Druid</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="weq">WeQ<a href="#weq" class="hash-link" aria-label="Direct link to WeQ" title="Direct link to WeQ">​</a></h2><p><a href="http://weq.com" target="_blank" rel="noopener noreferrer">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 class="anchor anchorWithStickyNavbar_LWe7" id="whylabs">WhyLabs<a href="#whylabs" class="hash-link" aria-label="Direct link to WhyLabs" title="Direct link to WhyLabs">​</a></h2><p><a href="https://whylabs.ai/" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">Migrating Our ML Insights Platform To Druid</a> (Drew Dahlke), <em>Imply <!-- -->[YouTube]</em>, 10 Dec 2021.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="wikimedia-foundation">Wikimedia Foundation<a href="#wikimedia-foundation" class="hash-link" aria-label="Direct link to Wikimedia Foundation" title="Direct link to Wikimedia Foundation">​</a></h2><p>We&#x27;re serving pageview data via Druid and Pivot.  Our internal customers are loving it and we&#x27;re working on allowing public access to sanitized data, both editing and pageview.  We like Druid because it&#x27;s open source, the folks that work on it have built a good community, and it&#x27;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" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">Analytics at Wikipedia</a></li><li><a href="https://speakerdeck.com/druidio/analytics-at-wikipedia-with-druid" target="_blank" rel="noopener noreferrer">Analytics at Wikipedia with Druid</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="wipro">Wipro<a href="#wipro" class="hash-link" aria-label="Direct link to Wipro" title="Direct link to Wipro">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="wiremind">Wiremind<a href="#wiremind" class="hash-link" aria-label="Direct link to Wiremind" title="Direct link to Wiremind">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="xiaomi">Xiaomi<a href="#xiaomi" class="hash-link" aria-label="Direct link to Xiaomi" title="Direct link to Xiaomi">​</a></h2><p>Xiaomi uses Druid as an analytics tool to analyze online advertising data.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="yahoo">Yahoo<a href="#yahoo" class="hash-link" aria-label="Direct link to Yahoo" title="Direct link to Yahoo">​</a></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" target="_blank" rel="noopener noreferrer">Druid Ecosystem at Yahoo</a></li><li><a href="http://yahooeng.tumblr.com/post/125287346011/complementing-hadoop-at-yahoo-interactive" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">Combining Druid and DataSketches for Real-time, Robust Behavioral Analytics</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="yeahmobi">YeahMobi<a href="#yeahmobi" class="hash-link" aria-label="Direct link to YeahMobi" title="Direct link to YeahMobi">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="yieldr">Yieldr<a href="#yieldr" class="hash-link" aria-label="Direct link to Yieldr" title="Direct link to Yieldr">​</a></h2><p><a href="https://www.yieldr.com" target="_blank" rel="noopener noreferrer">Yieldr</a> uses Druid to power real-time web and mobile analytics for airlines across the globe.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="youku-tudou">Youku Tudou<a href="#youku-tudou" class="hash-link" aria-label="Direct link to Youku Tudou" title="Direct link to Youku Tudou">​</a></h2><p>Youku Tudou employs Druid for real-time advertising analysis of huge volumes of data.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="youzan">Youzan<a href="#youzan" class="hash-link" aria-label="Direct link to Youzan" title="Direct link to Youzan">​</a></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 class="anchor anchorWithStickyNavbar_LWe7" id="zapr">Zapr<a href="#zapr" class="hash-link" aria-label="Direct link to Zapr" title="Direct link to Zapr">​</a></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/" target="_blank" rel="noopener noreferrer">Apache Druid: Sub-second Slice and Dice your Data!</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="zeotap">Zeotap<a href="#zeotap" class="hash-link" aria-label="Direct link to Zeotap" title="Direct link to Zeotap">​</a></h2><ul><li><a href="https://imply.io/post/apache-druid-helps-zeotap-master-multi-channel-attribution" target="_blank" rel="noopener noreferrer">Apache Druid helps Zeotap Master Multi-Channel Attribution at Scale</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="zhihu">Zhihu<a href="#zhihu" class="hash-link" aria-label="Direct link to Zhihu" title="Direct link to Zhihu">​</a></h2><p><a href="https://www.zhihu.com/" target="_blank" rel="noopener noreferrer">Zhihu</a> is a Chinese question-and-answer website. In Zhihu, Druid is used to power clients&#x27; 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 class="anchor anchorWithStickyNavbar_LWe7" id="zilingo">Zilingo<a href="#zilingo" class="hash-link" aria-label="Direct link to Zilingo" title="Direct link to Zilingo">​</a></h2><p>Zilingo&#x27;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 class="anchor anchorWithStickyNavbar_LWe7" id="zscaler">Zscaler<a href="#zscaler" class="hash-link" aria-label="Direct link to Zscaler" title="Direct link to Zscaler">​</a></h2><ul><li><a href="https://imply.io/post/druid-at-zscaler-security-log-analytics" target="_blank" rel="noopener noreferrer">Druid @ Zscaler - A Retrospective</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="zuoyebang">Zuoyebang<a href="#zuoyebang" class="hash-link" aria-label="Direct link to Zuoyebang" title="Direct link to Zuoyebang">​</a></h2><p><a href="https://www.zybang.com/" target="_blank" rel="noopener noreferrer">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" target="_blank" rel="noopener noreferrer">Add Your Company</a></p></article></div><div class="col col--2"><div class="tableOfContents_bqdL thin-scrollbar"><ul class="table-of-contents table-of-contents__left-border"><li><a href="#adikteev" class="table-of-contents__link toc-highlight">Adikteev</a></li><li><a href="#adswizz" class="table-of-contents__link toc-highlight">AdsWizz</a></li><li><a href="#airbnb" class="table-of-contents__link toc-highlight">Airbnb</a></li><li><a href="#airbridge" class="table-of-contents__link toc-highlight">Airbridge</a></li><li><a href="#alibaba" class="table-of-contents__link toc-highlight">Alibaba</a></li><li><a href="#allegro" class="table-of-contents__link toc-highlight">Allegro</a></li><li><a href="#alphaa-ai" class="table-of-contents__link toc-highlight">Alphaa AI</a></li><li><a href="#amobee" class="table-of-contents__link toc-highlight">Amobee</a></li><li><a href="#apollo-graphql" class="table-of-contents__link toc-highlight">Apollo GraphQL</a></li><li><a href="#appsflyer" class="table-of-contents__link toc-highlight">Appsflyer</a></li><li><a href="#archive-itorg" class="table-of-contents__link toc-highlight">Archive-It.org</a></li><li><a href="#athena-health" class="table-of-contents__link toc-highlight">Athena Health</a></li><li><a href="#atomx" class="table-of-contents__link toc-highlight">Atomx</a></li><li><a href="#autonomic" class="table-of-contents__link toc-highlight">Autonomic</a></li><li><a href="#avesta-technologies" class="table-of-contents__link toc-highlight">Avesta Technologies</a></li><li><a href="#bigo" class="table-of-contents__link toc-highlight">BIGO</a></li><li><a href="#billy-mobile" class="table-of-contents__link toc-highlight">Billy Mobile</a></li><li><a href="#blis" class="table-of-contents__link toc-highlight">Blis</a></li><li><a href="#blueshift" class="table-of-contents__link toc-highlight">Blueshift</a></li><li><a href="#bookingcom" class="table-of-contents__link toc-highlight">Booking.com</a></li><li><a href="#branch" class="table-of-contents__link toc-highlight">Branch</a></li><li><a href="#british-telecom-bt" class="table-of-contents__link toc-highlight">British Telecom (BT)</a></li><li><a href="#central-bank-of-the-republic-of-turkey" class="table-of-contents__link toc-highlight">Central Bank of the Republic of Turkey</a></li><li><a href="#charter-communications" class="table-of-contents__link toc-highlight">Charter Communications</a></li><li><a href="#circlehd" class="table-of-contents__link toc-highlight">CircleHD</a></li><li><a href="#cisco" class="table-of-contents__link toc-highlight">Cisco</a></li><li><a href="#condé-nast" class="table-of-contents__link toc-highlight">Condé Nast</a></li><li><a href="#confluent" class="table-of-contents__link toc-highlight">Confluent</a></li><li><a href="#contiamo" class="table-of-contents__link toc-highlight">Contiamo</a></li><li><a href="#criteo" class="table-of-contents__link toc-highlight">Criteo</a></li><li><a href="#crunchmetrics" class="table-of-contents__link toc-highlight">CrunchMetrics</a></li><li><a href="#cuebook" class="table-of-contents__link toc-highlight">Cuebook</a></li><li><a href="#dbs-bank" class="table-of-contents__link toc-highlight">DBS Bank</a></li><li><a href="#dataroid" class="table-of-contents__link toc-highlight">Dataroid</a></li><li><a href="#datumo" class="table-of-contents__link toc-highlight">Datumo</a></li><li><a href="#deepbi" class="table-of-contents__link toc-highlight">Deep.BI</a></li><li><a href="#deemaagency" class="table-of-contents__link toc-highlight">Deema.agency</a></li><li><a href="#delta-projects" class="table-of-contents__link toc-highlight">Delta Projects</a></li><li><a href="#didi-chuxing" class="table-of-contents__link toc-highlight">Didi Chuxing</a></li><li><a href="#dream11" class="table-of-contents__link toc-highlight">Dream11</a></li><li><a href="#easemob" class="table-of-contents__link toc-highlight">Easemob</a></li><li><a href="#ebay" class="table-of-contents__link toc-highlight">eBay</a></li><li><a href="#expedia" class="table-of-contents__link toc-highlight">Expedia</a></li><li><a href="#facilityconnex" class="table-of-contents__link toc-highlight">FacilityConneX</a></li><li><a href="#fanatics" class="table-of-contents__link toc-highlight">Fanatics</a></li><li><a href="#finin" class="table-of-contents__link toc-highlight">Finin</a></li><li><a href="#flipkart" class="table-of-contents__link toc-highlight">Flipkart</a></li><li><a href="#flurry-analytics" class="table-of-contents__link toc-highlight">Flurry Analytics</a></li><li><a href="#fullcontact" class="table-of-contents__link toc-highlight">FullContact</a></li><li><a href="#fyber" class="table-of-contents__link toc-highlight">Fyber</a></li><li><a href="#gameanalytics" class="table-of-contents__link toc-highlight">GameAnalytics</a></li><li><a href="#glia" class="table-of-contents__link toc-highlight">Glia</a></li><li><a href="#gumgum" class="table-of-contents__link toc-highlight">GumGum</a></li><li><a href="#hawk" class="table-of-contents__link toc-highlight">Hawk</a></li><li><a href="#hexaglobe" class="table-of-contents__link toc-highlight">Hexaglobe</a></li><li><a href="#hubvisor" class="table-of-contents__link toc-highlight">Hubvisor</a></li><li><a href="#hulu" class="table-of-contents__link toc-highlight">Hulu</a></li><li><a href="#icsoc-co-ltd" class="table-of-contents__link toc-highlight">ICSOC Co., Ltd.</a></li><li><a href="#ibotta" class="table-of-contents__link toc-highlight">Ibotta</a></li><li><a href="#imply" class="table-of-contents__link toc-highlight">Imply</a></li><li><a href="#inke" class="table-of-contents__link toc-highlight">Inke</a></li><li><a href="#inmobi" class="table-of-contents__link toc-highlight">Inmobi</a></li><li><a href="#innowatts" class="table-of-contents__link toc-highlight">Innowatts</a></li><li><a href="#interactive-intelligence" class="table-of-contents__link toc-highlight">Interactive Intelligence</a></li><li><a href="#ironsource" class="table-of-contents__link toc-highlight">ironSource</a></li><li><a href="#italiaonline" class="table-of-contents__link toc-highlight">Italiaonline</a></li><li><a href="#jolata" class="table-of-contents__link toc-highlight">Jolata</a></li><li><a href="#kering" class="table-of-contents__link toc-highlight">Kering</a></li><li><a href="#kt-nexr" class="table-of-contents__link toc-highlight">KT NexR</a></li><li><a href="#ldmobile" class="table-of-contents__link toc-highlight">LDMobile</a></li><li><a href="#libra-ai-technologies--papergo" class="table-of-contents__link toc-highlight">Libra AI Technologies &amp; PaperGo</a></li><li><a href="#lifebuzz" class="table-of-contents__link toc-highlight">LifeBuzz</a></li><li><a href="#liquidm" class="table-of-contents__link toc-highlight">LiquidM</a></li><li><a href="#lohika" class="table-of-contents__link toc-highlight">Lohika</a></li><li><a href="#lyft" class="table-of-contents__link toc-highlight">Lyft</a></li><li><a href="#lynx-analytics" class="table-of-contents__link toc-highlight">Lynx Analytics</a></li><li><a href="#makemytrip" class="table-of-contents__link toc-highlight">MakeMyTrip</a></li><li><a href="#makesens" class="table-of-contents__link toc-highlight">MAKESENS</a></li><li><a href="#marchex" class="table-of-contents__link toc-highlight">Marchex</a></li><li><a href="#metamarkets" class="table-of-contents__link toc-highlight">Metamarkets</a></li><li><a href="#millersoft" class="table-of-contents__link toc-highlight">Millersoft</a></li><li><a href="#mindhouse" class="table-of-contents__link toc-highlight">Mindhouse</a></li><li><a href="#mobiauto" class="table-of-contents__link toc-highlight">Mobiauto</a></li><li><a href="#monetate" class="table-of-contents__link toc-highlight">Monetate</a></li><li><a href="#mparticle" class="table-of-contents__link toc-highlight">mParticle</a></li><li><a href="#mz" class="table-of-contents__link toc-highlight">MZ</a></li><li><a href="#n3twork" class="table-of-contents__link toc-highlight">N3twork</a></li><li><a href="#naver" class="table-of-contents__link toc-highlight">Naver</a></li><li><a href="#netflix" class="table-of-contents__link toc-highlight">Netflix</a></li><li><a href="#netsil" class="table-of-contents__link toc-highlight">Netsil</a></li><li><a href="#nielsen-nielsen-marketing-cloud" class="table-of-contents__link toc-highlight">Nielsen (Nielsen Marketing Cloud)</a></li><li><a href="#nodex" class="table-of-contents__link toc-highlight">Nodex</a></li><li><a href="#noon" class="table-of-contents__link toc-highlight">Noon</a></li><li><a href="#ntt-com" class="table-of-contents__link toc-highlight">NTT Com</a></li><li><a href="#ocean-it" class="table-of-contents__link toc-highlight">Ocean IT</a></li><li><a href="#ona" class="table-of-contents__link toc-highlight">Ona</a></li><li><a href="#oneapm" class="table-of-contents__link toc-highlight">OneAPM</a></li><li><a href="#oppo" class="table-of-contents__link toc-highlight">Oppo</a></li><li><a href="#optimizely" class="table-of-contents__link toc-highlight">Optimizely</a></li><li><a href="#outbrain" class="table-of-contents__link toc-highlight">Outbrain</a></li><li><a href="#paypal" class="table-of-contents__link toc-highlight">Paypal</a></li><li><a href="#payu" class="table-of-contents__link toc-highlight">PayU</a></li><li><a href="#pinterest" class="table-of-contents__link toc-highlight">Pinterest</a></li><li><a href="#play-games24x7" class="table-of-contents__link toc-highlight">Play Games24x7</a></li><li><a href="#plumbr" class="table-of-contents__link toc-highlight">Plumbr</a></li><li><a href="#pollfish" class="table-of-contents__link toc-highlight">Pollfish</a></li><li><a href="#poshmark" class="table-of-contents__link toc-highlight">Poshmark</a></li><li><a href="#preset" class="table-of-contents__link toc-highlight">Preset</a></li><li><a href="#pubnative" class="table-of-contents__link toc-highlight">PubNative</a></li><li><a href="#quantiply" class="table-of-contents__link toc-highlight">Quantiply</a></li><li><a href="#raygun" class="table-of-contents__link toc-highlight">Raygun</a></li><li><a href="#razorpay" class="table-of-contents__link toc-highlight">Razorpay</a></li><li><a href="#redborder" class="table-of-contents__link toc-highlight">Redborder</a></li><li><a href="#reddit" class="table-of-contents__link toc-highlight">Reddit</a></li><li><a href="#retargetly" class="table-of-contents__link toc-highlight">Retargetly</a></li><li><a href="#rill-data" class="table-of-contents__link toc-highlight">Rill Data</a></li><li><a href="#roambee" class="table-of-contents__link toc-highlight">Roambee</a></li><li><a href="#rovio" class="table-of-contents__link toc-highlight">Rovio</a></li><li><a href="#rubicon-project" class="table-of-contents__link toc-highlight">Rubicon Project</a></li><li><a href="#sage--archer" class="table-of-contents__link toc-highlight">Sage + Archer</a></li><li><a href="#salesforce" class="table-of-contents__link toc-highlight">Salesforce</a></li><li><a href="#scalac" class="table-of-contents__link toc-highlight">Scalac</a></li><li><a href="#shopee" class="table-of-contents__link toc-highlight">Shopee</a></li><li><a href="#shopify" class="table-of-contents__link toc-highlight">Shopify</a></li><li><a href="#sift-science" class="table-of-contents__link toc-highlight">Sift Science</a></li><li><a href="#signoz" class="table-of-contents__link toc-highlight">SigNoz</a></li><li><a href="#sina-weibo" class="table-of-contents__link toc-highlight">Sina Weibo</a></li><li><a href="#singular" class="table-of-contents__link toc-highlight">Singular</a></li><li><a href="#sk-telecom" class="table-of-contents__link toc-highlight">SK Telecom</a></li><li><a href="#skimlinks" class="table-of-contents__link toc-highlight">Skimlinks</a></li><li><a href="#skyport-systems" class="table-of-contents__link toc-highlight">Skyport Systems</a></li><li><a href="#slack" class="table-of-contents__link toc-highlight">Slack</a></li><li><a href="#smart-bid" class="table-of-contents__link toc-highlight">Smart Bid</a></li><li><a href="#smyte" class="table-of-contents__link toc-highlight">Smyte</a></li><li><a href="#snap-inc" class="table-of-contents__link toc-highlight">Snap, Inc.</a></li><li><a href="#societe-generale" class="table-of-contents__link toc-highlight">Societe Generale</a></li><li><a href="#splunk" class="table-of-contents__link toc-highlight">Splunk</a></li><li><a href="#spotx" class="table-of-contents__link toc-highlight">SpotX</a></li><li><a href="#streamlyzer" class="table-of-contents__link toc-highlight">Streamlyzer</a></li><li><a href="#sugo" class="table-of-contents__link toc-highlight">Sugo</a></li><li><a href="#superawesome" class="table-of-contents__link toc-highlight">SuperAwesome</a></li><li><a href="#sweet-couch" class="table-of-contents__link toc-highlight">Sweet Couch</a></li><li><a href="#swisscom" class="table-of-contents__link toc-highlight">Swisscom</a></li><li><a href="#talkingdata" class="table-of-contents__link toc-highlight">TalkingData</a></li><li><a href="#target" class="table-of-contents__link toc-highlight">Target</a></li><li><a href="#telemetrydeck-analytics" class="table-of-contents__link toc-highlight">TelemetryDeck Analytics</a></li><li><a href="#tencent" class="table-of-contents__link toc-highlight">Tencent</a></li><li><a href="#time-warner-cable" class="table-of-contents__link toc-highlight">Time Warner Cable</a></li><li><a href="#trafficguard" class="table-of-contents__link toc-highlight">TrafficGuard</a></li><li><a href="#trendyolcom---alibaba-group-company" class="table-of-contents__link toc-highlight">Trendyol.com - Alibaba Group Company</a></li><li><a href="#triplelift" class="table-of-contents__link toc-highlight">TripleLift</a></li><li><a href="#tripstack" class="table-of-contents__link toc-highlight">TripStack</a></li><li><a href="#triton-digital" class="table-of-contents__link toc-highlight">Triton Digital</a></li><li><a href="#truecar" class="table-of-contents__link toc-highlight">TrueCar</a></li><li><a href="#trustpilot" class="table-of-contents__link toc-highlight">Trustpilot</a></li><li><a href="#twitch" class="table-of-contents__link toc-highlight">Twitch</a></li><li><a href="#twitter" class="table-of-contents__link toc-highlight">Twitter</a></li><li><a href="#unity" class="table-of-contents__link toc-highlight">Unity</a></li><li><a href="#verizon" class="table-of-contents__link toc-highlight">Verizon</a></li><li><a href="#videoamp" class="table-of-contents__link toc-highlight">VideoAmp</a></li><li><a href="#vigiglobe" class="table-of-contents__link toc-highlight">Vigiglobe</a></li><li><a href="#viralgains" class="table-of-contents__link toc-highlight">ViralGains</a></li><li><a href="#virool" class="table-of-contents__link toc-highlight">Virool</a></li><li><a href="#vserv" class="table-of-contents__link toc-highlight">Vserv</a></li><li><a href="#walkme" class="table-of-contents__link toc-highlight">WalkMe</a></li><li><a href="#walmart" class="table-of-contents__link toc-highlight">Walmart</a></li><li><a href="#weq" class="table-of-contents__link toc-highlight">WeQ</a></li><li><a href="#whylabs" class="table-of-contents__link toc-highlight">WhyLabs</a></li><li><a href="#wikimedia-foundation" class="table-of-contents__link toc-highlight">Wikimedia Foundation</a></li><li><a href="#wipro" class="table-of-contents__link toc-highlight">Wipro</a></li><li><a href="#wiremind" class="table-of-contents__link toc-highlight">Wiremind</a></li><li><a href="#xiaomi" class="table-of-contents__link toc-highlight">Xiaomi</a></li><li><a href="#yahoo" class="table-of-contents__link toc-highlight">Yahoo</a></li><li><a href="#yeahmobi" class="table-of-contents__link toc-highlight">YeahMobi</a></li><li><a href="#yieldr" class="table-of-contents__link toc-highlight">Yieldr</a></li><li><a href="#youku-tudou" class="table-of-contents__link toc-highlight">Youku Tudou</a></li><li><a href="#youzan" class="table-of-contents__link toc-highlight">Youzan</a></li><li><a href="#zapr" class="table-of-contents__link toc-highlight">Zapr</a></li><li><a href="#zeotap" class="table-of-contents__link toc-highlight">Zeotap</a></li><li><a href="#zhihu" class="table-of-contents__link toc-highlight">Zhihu</a></li><li><a href="#zilingo" class="table-of-contents__link toc-highlight">Zilingo</a></li><li><a href="#zscaler" class="table-of-contents__link toc-highlight">Zscaler</a></li><li><a href="#zuoyebang" class="table-of-contents__link toc-highlight">Zuoyebang</a></li></ul></div></div></div></main></div><footer class="footer"><div class="container container-fluid"><div class="footer__bottom text--center"><div class="margin-bottom--sm"><img src="/img/favicon.png" class="themedImage_ToTc themedImage--light_HNdA footer__logo"><img src="/img/favicon.png" class="themedImage_ToTc themedImage--dark_i4oU footer__logo"></div><div class="footer__copyright">Copyright © 2023 Apache Software Foundation. Except where otherwise noted, licensed under CC BY-SA 4.0. 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></div></footer></div>
<script src="/assets/js/runtime~main.4c9a7172.js"></script>
<script src="/assets/js/main.3a5ab01b.js"></script>
</body>
</html>