AppLovin: The Ad Exchange Playing Both Sides
AppLovin occupies a peculiar coordinate in the mobile economy: it is simultaneously a landlord and a tenant, a competitor and the infrastructure upon which competitors depend. The company operates billions of ad auctions daily across roughly one hundred thousand applications, matching developers who need users with advertisers who need engaged audiences. Yet unlike pure advertising exchanges, AppLovin owns a portfolio of game studios, Lion Studios and others, that develop mobile titles competing directly against the very developers whose data it solicits. This is not a casual corporate diversification. It is the essential, uncomfortable foundation of the entire economic engine.
The business generates revenue by solving a specific coordination failure in mobile app distribution. Developers create software, but they lack the capital and expertise to acquire users at scale. Advertisers, often the same developers buying installs for their own titles, need to reach high-value players who will spend money or watch ads. AppLovin sits between them with two core products: MAX, a mediation platform that runs real-time auctions for ad inventory across competing networks including Facebook, Google, and Amazon; and AppDiscovery, a user acquisition tool where advertisers set performance targets and the system automates pricing and targeting to meet them. The margin expansion does not come from salesmanship or exclusive contracts. It comes from a machine learning optimizer that improves with every signal it ingests, session length, transaction behavior, player progression velocity, and the critical, contested fact that AppLovin generates many of these signals internally through its owned games.
The Optimization Engine Requires Its Own Competition
The flywheel began turning in earnest in 2018, when AppLovin made the deliberate decision to enter game development. Prior to this, the company faced a data starvation problem. Third-party developers were reluctant to share deep engagement telemetry with an advertising network. They feared, reasonably, that feeding proprietary behavioral data into a centralized optimizer would ultimately train models that benefited their competitors. Without granular signals, how long a player lasts, where they churn, when they pay, the machine learning systems could only optimize against superficial metrics like click-through rates or install counts. These are blunt instruments in an industry where the difference between a profitable user and a costly acquisition often depends on whether someone reaches level seven or level twelve within the first forty-eight hours.
AppLovin solved this by becoming its own customer. It acquired and built game studios not primarily to generate content revenue, but to create a controlled environment for data generation. Owned games provided the deep engagement signals that third parties withheld. The optimizer learned to predict lifetime value not from cooperative data sharing, but from the complete visibility AppLovin enjoyed over its own titles. Once the system demonstrated superior performance, delivering users who actually spent money or engaged deeply, external developers faced a prisoner’s dilemma. They could withhold data and accept inferior targeting, or they could share their telemetry and benefit from an optimizer trained on signals they could never access independently. Most chose to share.
This created the closed loop that now defines the company’s structural advantage. Each new advertiser adds demand that increases fill rates for developer inventory. Each new developer adds inventory that attracts more advertisers. And every participant, willingly or not, adds data that refines the optimizer for all. The compounding effect is measurable in the revenue trajectory: from roughly $200 million to $670 million, and toward projections of $1.4 billion to $2 billion annually. The growth has been achieved without a traditional sales force, driven instead by the self-reinforcing mathematics of better targeting.
Yet the engine runs on a specific, volatile fuel. The data that trains the optimizer comes substantially from AppLovin’s owned content, which competes directly against the developers it serves. This is not a peripheral tension. It is the central architectural compromise that makes the entire system possible.
The Structural Impossibility of Neutral Ownership
The mobile gaming industry operates on a brutal zero-sum logic. User attention is finite, and the cost of acquiring a high-value player rises as inventory saturates. When AppLovin owns studios that publish hyper-casual or mid-core titles, it is not merely participating in the market; it is competing for the same cohorts of players that its advertising customers target. A developer using AppDiscovery to acquire users for a puzzle game may find itself bidding against AppLovin’s internal studios for the same high-engagement audience segments. The developer pays AppLovin to optimize its campaigns, while AppLovin uses the resulting data to improve its own game’s performance.
This creates a permanent state of structural hypocrisy. AppLovin must maintain the fiction of neutrality, the posture of a neutral utility providing infrastructure, while functioning as an active competitor extracting maximum value from the data flowing through its pipes. Developers tolerate this because the returns are demonstrable. The optimizer works. It delivers users who generate revenue within the twenty-four to thirty-day window that defines performance-based mobile advertising. But the tolerance is conditional and grudging.
The fragility lies in the moment when developers recognize the asymmetry. AppLovin sees everything: the performance of every campaign, the revenue curves of every title, the behavioral patterns of every cohort. Developers see only their own results. They must trust that AppLovin does not use this comprehensive visibility to advantage its internal studios, rioritizing their bids, reserving premium inventory, or cloning successful mechanics. There is no contractual mechanism that fully resolves this conflict. AppLovin has attempted to segregate its studios operationally, but data is fluid. The same engagement signals that improve targeting for external developers inevitably improve game design and monetization for internal titles.
If major developers were to collectively withhold deep engagement data, reverting to superficial metrics out of competitive paranoia, the optimizer’s accuracy would degrade. Advertiser return on investment would fall. The flywheel would slow. The company is therefore locked in a perpetual credibility balancing act: it must prove the optimizer’s superiority to attract data, but not so obviously exploit that data that customers defect. It must compete aggressively in games to generate training signals, but not so aggressively that it triggers an exodus of the developers who provide the inventory and third-party data that complete the network.
The Thirty-Day Guillotine
Compounding this tension is a pricing model that offers no shelter from failure. AppLovin operates on pure performance. Advertisers set specific goals, spend one thousand dollars to generate one hundred dollars in revenue within thirty days, and the system either delivers or the spend stops. There are no annual contracts, no minimum commitments, no brand advertising retainers that smooth revenue across quarters. The relationship lasts exactly as long as the optimizer maintains its edge.
This creates a zero-gravity revenue line. In traditional enterprise software or brand advertising, relationships persist through temporary underperformance due to switching costs, contractual inertia, or the opacity of measurement. A brand might not know for months whether a campaign worked. AppLovin’s customers know within twenty-four to thirty days. If the machine learning models drift, if a competitor’s optimizer achieves materially better return on ad spend for a specific genre or geography, or if market saturation reduces the availability of high-value users, advertisers can redirect budgets instantly. There is no friction to delay the fall.
The model therefore requires continuous, provable superiority. The optimizer cannot merely be good; it must be consistently better than alternatives, measured in real time, across thousands of simultaneous campaigns. A temporary algorithm failure, a privacy regulation that degrades signal quality, or a shift in Apple’s or Google’s policies that restricts data collection, does not trigger a gradual decline. It triggers an immediate revenue cliff as performance marketers, ruthlessly rational actors, reallocate spend to Facebook, Google, or TikTok’s advertising platforms.
This fragility is inherent to the value proposition. The automation that allows AppLovin to scale without a sales force, the lean, self-serve interface where customers set parameters and the machine handles execution, also eliminates the human relationships that might cushion temporary technical failures. The efficiency is brutal in both directions.
Capital Structure as Operating Model
There is an underappreciated dimension to AppLovin’s durability that predates the data flywheel and the owned-game strategy. In late 2012, the company attempted to raise venture capital and failed. Investors dismissed the opportunity; ad tech and mobile games were considered unattractive categories, crowded with me-too competitors and dependent on the whims of platform owners. The rejection forced a counterintuitive capital structure. Adam Foroughi, the founder, funded growth through personal capital and angel investors, achieving profitability by the end of 2012 and avoiding the dilution that typically accompanies scaling in Silicon Valley.
This funding failure became a structural advantage. Without abundant venture capital to burn, AppLovin could not afford to build the sales-heavy, labor-intensive organizations that characterized its well-funded competitors. It was forced to automate. The product had to sell itself. The optimizer had to improve without armies of data scientists and account managers. The company built a cost structure that was lean by necessity, with margins higher than peers who had raised hundreds of millions to hire aggressively.
When the mobile advertising industry consolidated, hen competitors who had spent lavishly on sales teams and manual campaign management found themselves unable to achieve unit economics that justified their burn rates, ppLovin survived as the last independent standing. The automation-first architecture, born of capital scarcity, proved more scalable and resilient than the human-heavy models of the venture-backed class.
Foroughi’s retained ownership stake, significantly larger than typical for a company of this scale, functions as an economic variable rather than merely a governance curiosity. It aligns incentives toward long-term optimization and margin preservation rather than growth-at-all-costs scaling. The culture that emerged, technical, frugal, focused on machine learning efficiency rather than relationship management, reflects this capital discipline. Competitors that raised capital early built organizations that are now difficult to unwind; their cost structures are baked into headcounts and office footprints that AppLovin never incurred. The automation is not just a product feature; it is a defensive moat against competitors with higher overhead.
The Duopoly’s Tolerance Is Conditional
The entire edifice rests upon a fragile permission. Apple and Google control the infrastructure of mobile distribution: he app stores, the operating systems, the privacy frameworks, and increasingly, the advertising systems themselves. AppLovin exists within their walled gardens at their pleasure. It has no contractual protection against exclusion, no structural guarantee of access. The company maintains what it describes as “non-contentious” relationships with the platforms, positioning itself as a driver of app store consumption that benefits the duopoly’s core revenue streams. The argument is structural: by helping developers acquire users and monetize through ads, AppLovin increases the total economic activity within the iOS and Android ecosystems, justifying the thirty percent tax the platforms levy on transactions.
Yet this neutrality is increasingly precarious. Apple has already demonstrated its willingness to disrupt mobile advertising through App Tracking Transparency, the privacy framework that required opt-in consent for cross-app tracking and materially damaged the targeting capabilities of the entire industry. Google competes directly with AppLovin on the advertiser side through its own user acquisition products. Both platforms have incentives to centralize advertising within their own walls, capturing the margins that AppLovin now claims.
The multi-dimensional relationship, AppLovin as app developer, advertiser, cloud customer, and ecosystem driver, provides some insulation. The platforms cannot easily restrict AppLovin without harming legitimate developers who depend on its tools for monetization. But this protection is political and economic, not legal or technical. If Apple or Google decide that third-party ad networks represent a competitive threat to their own advertising ambitions, or if regulatory pressure forces them to restrict data sharing further, AppLovin’s access could be curtailed overnight. The optimizer’s effectiveness depends on data signals that flow through operating systems the company does not control. A policy change that eliminates device-level behavioral tracking would degrade the machine learning systems below the threshold of competitive viability, triggering the thirty-day churn cycle without recourse.
When the Commons Closes
There is a final, subtler fragility embedded in the data strategy. AppLovin assumes that developers will continue to share deep engagement data voluntarily once they observe the returns. But this assumes a static understanding of competitive dynamics. As developers mature, they may recognize that the optimizer does not merely improve their individual returns; it trains a general model that improves returns for their competitors as well. The data they contribute becomes a public good within AppLovin’s closed network, benefiting rivals who target similar audience segments.
A developer sharing data about high-value puzzle game players is, in effect, helping AppLovin identify those players for every other puzzle game advertiser. The individual benefit remains positive, targeting improves, but the collective effect is the commoditization of user acquisition advantage. Once developers fully internalize this, the voluntary data sharing that sustains the flywheel may stall. They may revert to withholding deep signals, accepting less efficient targeting in exchange for keeping their audience insights proprietary.
This is the tragedy of the data commons. The optimizer requires universal participation to maintain its edge, but each participant has incentives to free-ride or defect. AppLovin mitigates this through its owned games, which provide baseline training data regardless of third-party cooperation. Yet if the third-party data stream dries up due to privacy regulation, competitive suspicion, or platform restrictions, the optimizer loses its comparative advantage. It becomes merely one of several adequate targeting systems, indistinguishable from the platform-native tools offered by Apple and Google.
The company has scaled to billions in revenue by navigating these contradictions: competing with customers while serving them, automating relationships that traditionally required human trust, and extracting value from data while maintaining the pretense of neutrality. The engine runs as long as the optimizer stays ahead, the platforms tolerate the independence, and the developers remain willing to feed the machine that trains their rivals. It is a high-wire performance without a net, where the fall is as sudden as the ascent.
It is a high-wire performance without a net, where the fall is as sudden as the ascent. Consider the mechanics of the thirty-day window in practice. A mid-tier mobile game studio launches a campaign on AppDiscovery with a target: spend fifty thousand dollars to generate fifteen thousand dollars in revenue within thirty days, achieving a return on ad spend of 1.3 when factoring in projected lifetime value. The optimizer ingests the app’s historical data, retention curves, level progression rates, purchase timing, and begins purchasing inventory across the network. For the first seventy-two hours, the algorithm explores, testing cohorts of users across different ad formats and publishers. By day seven, it begins to concentrate spend on the segments showing early positive signals: users who reach the tutorial completion, who engage with the gacha mechanics, who do not immediately bounce at the paywall.
If by day fourteen the cohort is tracking toward the revenue target, the advertiser increases spend, feeding the flywheel. The developer shares deeper telemetry, specifically, which in-game events correlate with long-term value, trusting that this granularity will improve targeting specificity. But if by day twenty-one the revenue per install falls short, if the optimizer has misidentified high-intent users and purchased a cohort that churns before monetizing, the advertiser does not merely reduce spend. They pause immediately, redirecting the fifty thousand dollars to TikTok or Meta or Google Ads. There is no account executive to call, no contractual minimum to fulfill, no relationship capital to burn. The revenue line for that customer drops to zero before the month closes, and the data that customer might have contributed, signals from their app that would have improved the model for all subsequent campaigns, never enters the system.
This is the probabilistic nature of the guarantee. The machine learning models predict outcomes based on historical patterns, but mobile gaming markets shift weekly. A competitor launches a similar title, saturating the creative landscape and driving up install costs. A TikTok trend redirects user attention away from puzzle games toward simulation titles. The optimizer, trained on last month’s behavioral clusters, continues purchasing against obsolete signals. The result is not gradual underperformance but acute failure: the advertiser misses their thirty-day target by forty percent, blames the algorithm, and departs. Because the model is automated, there is no human intervention to catch the drift, no sales team to explain the variance, only the binary outcome of the dashboard.
The fragility compounds because the data that prevents such drift is itself a contested resource. When a developer of a successful match-three game shares engagement data, specifically, that users who complete level fifteen within the first session have a seventy percent probability of becoming paying customers, this signal does not remain proprietary to their campaigns. It trains the general model. The optimizer learns to seek level-fifteen completionists across the entire network, identifying them not merely for the original developer but for every subsequent match-three advertiser. The developer who contributed the insight finds themselves bidding against rivals for the exact cohort they helped define, driving up acquisition costs through their own data contribution.
This is the tragedy of the data commons in operational detail. Developers participate because the individual return exceeds the collective cost; the targeting improvement for their campaigns outweighs the competitive disadvantage of training shared models. But this equilibrium holds only as long as the advantage remains opaque. As the developer matures, as their analytics team recognizes that their proprietary engagement curves are being used to optimize competitors’ campaigns, the rational response is data withholding. They revert to sharing only superficial metrics, installs, basic retention, while keeping the deep behavioral signals that distinguish high-value users from the merely curious. When this happens, the optimizer loses granularity. It cannot distinguish between a user who will spend two hundred dollars over six months and one who will never open the app again. Advertiser ROI degrades across the network, triggering the thirty-day churn cycle not from algorithmic failure but from data starvation.
AppLovin attempts to mitigate this through its owned studios, which generate training data regardless of third-party cooperation. Lion Studios and the internal portfolio produce the engagement signals that keep the model functional even when external developers defect. But this creates the competitive conflict in its most acute form. When AppLovin’s internal studios publish a hyper-casual puzzle game, they have complete visibility into the performance of every competing puzzle game on the platform. They see which creative concepts convert, which audience segments show affinity, which monetization mechanics drive revenue. They can clone successful mechanics with perfect market timing, targeting the same high-value users that external developers paid AppLovin to acquire. The external developer sees only their own campaign performance; AppLovin sees the entire competitive landscape.
The company’s operational response, firewalls between the studios and the ad tech platform, is structurally insufficient. Data is not siloed like physical inventory; it is fluid, statistical, ambient. The optimizer that improves because Lion Studios generated a million high-signal user sessions cannot easily forget what it learned when serving external customers. The knowledge that level-fifteen completion predicts value in one game necessarily informs the prediction of value in similar titles. The firewall is a legal and organizational fiction that cannot contain statistical inference.
This tension becomes existential when considering expansion beyond mobile’s core categories. AppLovin scaled without a sales force by building self-serve tools for developers who understood performance marketing intuitively. But emerging verticals, Connected Television, blockchain gaming, subscription-based wellness apps, require different muscles. CTV advertising involves negotiations with streaming platforms, creative customization for television formats, and relationships with media buyers who do not work in thirty-day performance windows. Blockchain gaming operates in regulatory gray zones and requires education about wallet-based user acquisition. These markets do not lend themselves to automated, self-serve interfaces. They require sales expertise, local partnerships, and human relationship management: he exact organizational capabilities AppLovin deliberately avoided building.
The strategic tension is acute: the lean, automated operating model that generated superior margins in mobile gaming becomes a constraint when addressing markets that require consultative selling. Hiring a sales force to attack CTV would degrade the cost structure that survived the consolidation wars. Yet refusing to hire one cedes these growth markets to competitors who built relationship-heavy organizations from the start. The company is trapped by its own efficiency.
Meanwhile, the temperature of the platform relationship requires constant monitoring. When Apple implemented App Tracking Transparency in 2021, requiring users to opt-in to cross-app tracking, the mobile advertising industry convulsed. Meta, dependent on the iOS identifier for advertisers (IDFA), saw its targeting efficiency collapse and its stock valuation fall by hundreds of billions. AppLovin survived, in part because its owned games provided first-party data that did not rely on Apple’s tracking infrastructure, and in part because its optimizer had already learned to predict value from in-app behavior rather than external identity graphs. But the survival was precarious and partial. The ATT framework degraded signal quality across the ecosystem, increasing the cost of acquiring high-value users and narrowing the margin for error in the thirty-day window.
The relationship with Apple remains “non-contentious” only as long as AppLovin does not threaten to capture advertising revenue that Apple covets for itself. The App Store generates billions in commission revenue from in-app purchases; advertising that drives those purchases is tolerated as a complementary service. But as Apple expands its own advertising network, placing ads in the App Store, in Apple News, in the Stocks app, it increasingly competes directly with AppLovin for the same advertiser dollars. The tolerance is conditional on AppLovin remaining subscale or operationally dependent, never challenging the platform’s primary advertising ambitions. If AppLovin’s growth in a specific vertical, say, casual gaming, becomes large enough to represent a meaningful shift of advertising spend away from Apple’s own inventory, the policy environment could shift. Apple could restrict AppLovin’s access to SKAdNetwork data, the attribution framework that allows advertisers to measure campaign success without IDFA. It could delay AppLovin’s app updates during review, or reject them entirely citing technical violations. There is no recourse. The duopoly does not negotiate with infrastructure; it permits it.
Google presents a different but equally severe threat. Unlike Apple, Google competes directly on the advertiser side through Google Ads and Firebase, offering user acquisition tools that are deeply integrated with Android’s operating system. AppLovin operates on Android through the grace of the same platform that offers competing services with preferential access to data and distribution. If Google decides to prioritize its own user acquisition tools in the Android ecosystem, surfacing them in the Play Store, integrating them into developer dashboards, or restricting third-party SDKs for privacy reasons, AppLovin’s position on the dominant mobile platform becomes precarious.
The bear case, fully realized, looks like this: A privacy regulation in the European Union or a policy shift by Apple eliminates the ability to share device-level engagement data across apps. Developers, already suspicious of AppLovin’s competitive position, withhold deep telemetry entirely. The optimizer, suddenly starved of training signals, begins to miss thirty-day targets with increasing frequency. Advertisers, operating without contractual lock-in, pause campaigns within hours of detecting underperformance. Revenue falls not gradually but cliff-like, quarter over quarter, because there are no annual contracts to smooth the decline. The owned studios continue to generate data, but without the third-party data that provided cross-app behavioral context, the optimizer cannot match the performance of platform-native tools offered by Apple and Google, which have access to first-party data that regulations prevent AppLovin from touching.
In this scenario, the capital structure that provided advantage becomes vulnerability. The high ownership concentration means limited external governance pressure to pivot or diversify. The automation-first culture, built to avoid the costs of human sales and account management, cannot easily retool to compete on relationship or service. The company has optimized for a specific equilibrium, high velocity, low friction, algorithmic mediation, and lacks the organizational slack to survive a paradigm shift toward privacy, human sales, or platform centralization.
Yet there remains the underappreciated resilience of the multi-touch relationship. AppLovin is not merely an ad network to Apple and Google; it is a significant app developer in its own right, publishing titles that drive App Store engagement and commission revenue. It is a cloud customer, paying for infrastructure. It is an ecosystem driver, helping thousands of small developers monetize and survive, which in turn justifies the platform’s thirty percent tax on transactions. This multidimensional entanglement creates friction against exclusion. Apple could destroy AppLovin’s ad business, but in doing so it would damage the game studios that generate valuable content for iOS, and the small developers who depend on AppLovin’s tools to survive. The platform would be cutting off revenue streams that ultimately flow back to the platform itself.
The question is whether this structural entanglement provides sufficient protection against the platforms’ own strategic imperatives. As Apple and Google face regulatory pressure to open their ecosystems, they may view independent ad networks as acceptable casualties in the effort to maintain control over primary revenue streams. The advertising business offers higher margins than app store commissions; if forced to reduce the thirty percent tax, Apple and Google may seek to replace that revenue by capturing advertising spend directly. In such a transition, AppLovin’s multi-dimensional value becomes a target rather than a shield.
Adam Foroughi’s retained ownership stake, significantly higher than typical for companies of this scale, functions here as a strategic variable with quantitative consequences. Without the dilution of venture capital, without the governance structures that force quarterly optimization for growth, the company can afford to maintain the “non-contentious” posture with platforms even when aggressive expansion might yield short-term revenue. The founder can choose to remain subscale in specific verticals, to avoid challenging Apple or Google directly in their core advertising businesses, because the equity structure does not demand maximum addressable market capture. This patience, born of capital independence, may be the only protection against platform retaliation.
But patience has limits. The data flywheel requires continuous expansion. Every quarter without new data sources, new inventory, or new advertiser demand, the model risks stagnation. Machine learning systems do not merely require data; they require fresh data, new patterns, expanding feature spaces. If the optimizer stops encountering new user behaviors, if the network stops growing, the model drifts into overfitting, optimizing for historical patterns that no longer obtain. The thirty-day window becomes harder to hit not because of competitive pressure but because the algorithm has memorized rather than learned.
Thus the company must grow, yet cannot grow into markets that require sales forces. It must collect data, yet cannot force developers to share against their competitive interest. It must optimize for thirty-day returns, yet cannot guarantee them in volatile markets. It must remain independent of the platforms, yet cannot survive their exclusion. The high-wire act continues, the net remains absent, and the wind, measured in privacy regulations, platform policy shifts, and developer defections, continues to rise.
The constraints become visible when AppLovin contemplates replication of its mobile success in Connected Television. Unlike mobile games, where a developer can upload a build, integrate an SDK, and launch a campaign without speaking to a human, CTV advertising requires negotiation with streaming platforms that control inventory in annual upfronts, creative adaptation for fifteen-second versus thirty-second formats, and technical integration with fragmented device manufacturers from Roku to Samsung. A performance marketer at a direct-to-consumer brand seeking to acquire subscribers for a documentary streaming service cannot simply set a thirty-day revenue target in a dashboard and allow an algorithm to purchase inventory across Netflix, Hulu, and Peacock. They require insertion orders that specify content adjacency, frequency caps that prevent creative wear-out, and make-goods when delivery falls short. These require sales relationships, and sales relationships require the exact organizational overhead, headcount, offices, account management layers, that AppLovin avoided building to survive the mobile consolidation.
The automated bidding systems that optimize mobile ad auctions in milliseconds would encounter CTV inventory pools that clear in daily batches, requiring manual pacing decisions by media buyers who understand which programming blocks index high for specific demographic cohorts. The machine learning models trained on touch-screen engagement patterns, swipes, taps, session length, would find no corollary in television viewing behavior, where the signal of “engagement” is whether a viewer remains on the couch during commercial breaks, data points that require panel-based measurement and probabilistic matching rather than deterministic device graphs. The self-serve interface, designed for mobile developers who live inside the metrics of cost-per-install and day-seven retention, would baffle television media buyers who speak in gross rating points and reach frequency curves, and who expect account executives to revise creative strategy based on quarterly brand lift studies.
The result is structural mismatch rather than mere slow adoption. AppLovin can either hire the sales force necessary to translate between algorithmic optimization and television’s relationship-based commerce, abandoning the cost structure that provides its margin advantage, or retreat to the automated mobile core, conceding the next billion-dollar advertising market to competitors who have spent a decade building the human infrastructure AppLovin automated away. The choice reveals the rigidity of the model: the automation that enabled scale in one context becomes a cage in another, and the capital efficiency that saved the company during the mobile wars now prevents it from fighting the next battle. The high-wire, it turns out, does not extend across the chasm to the next peak.