hv71

When the puck drops at an HV71 home game, the action isn't confined to the ice. Beneath the stands, a distributed system of event brokers, edge nodes. And CDN caches hums in synchrony, ingesting telemetry from concession stands, ticketing scanners. And thousands of mobile devices. The real secret behind HV71's fan-first digital strategy isn't just content-it's a distributed event pipeline that processes 50,000 sensor readings per second at match time. This post dissects the engineering decisions that turn a 90-minute hockey game into a continuous feedback loop between the arena, the cloud. And the fan in the seat.

I've spent the last decade helping sports franchises migrate from brochure-ware mobile apps to real-time engagement platforms. When the HV71 team approached us with a brief that read, "We want every fan to feel like they're part of the bench," I knew the real work wouldn't be in the UI layer. It would be in the data plane: how fast can we ingest, enrich,? And fan-out a face-off win to 7,000 concurrent app sessions before the next line change? That's the kind of architectural pressure that separates a weekend hackathon from a production-grade system.

In the following deep dive, I'll walk through the concrete stack we landed on-from the Kafka topic topology to the edge compute units we deployed inside the Husqvarna Garden arena. I'll share the numbers we pulled from our Grafana dashboards after 50 live matches, and I'll flag the failure modes that only appear when a thousand fans simultaneously request a replay clip after a controversial goal. If you've ever wondered what it takes to make a mobile app feel as fast as the sport it covers, this is the blueprint.

The Invisible Infrastructure Powering Modern Sports Franchises

Most fans open their HV71 app, scan a QR-coded ticket and never think about the machinery behind that 200-millisecond response. Yet every scan hits a serverless function that validates a signed JWT, checks a seat map cache. And Updates a real-time occupancy heat map consumed by security operations. This isn't just a ticketing flow-it's a low-latency, high-consistency write path that must tolerate sudden bursts of 2,000 requests per second at door opening.

Under the hood, the infrastructure leans on AWS Wavelength zones deployed at the telecom edge within a kilometer of the arena. By running API Gateway and Lambda@Edge functions in these zones, we avoid sending authentication packets all the way to Stockholm's regional data center. The result is a 10x reduction in round-trip time for latency-critical operations. Sports franchises often overlook edge computing because their IT teams come from enterprise ITIL backgrounds. But the physics of radio waves doesn't care about organizational inertia-every millisecond matters when a fan is standing in a cold queue.

HV71's infrastructure is invisible by design. The operations team doesn't think about node recycling or Kafka partition rebalancing during a playoff overtime; those responsibilities are codified in Terraform modules and automated by SLO-driven runbooks. This is the distance between building a "working" app and building a resilient platform that doesn't wake you up at 2 a m because a memory leak coincided with a hat-trick celebration.

Why Generic Fan Apps Fail Under Peak Load

I've reviewed architecture diagrams from a dozen Swedish Hockey League teams, and the pattern is depressingly familiar: a RESTful monolith behind an AWS Elastic Load Balancer, Redis used as a session store, and a MySQL RDS instance that spikes to 100% CPU during the second intermission. When a goal is scored, thousands of clients poll the same /live-score endpoint. And the database's read replica craters under the thundering herd. That's not a scaling problem; it's a design anti-pattern that confuses fan engagement with a CRUD application.

The HV71 app avoids this by treating every live event-shots, penalties, goals-as an immutable event published to Apache Kafka. The client subscribes to a WebSocket stream that's itself backed by Kafka topics, and no one polls; the server pushes deltasIn production, we measured a median end-to-end latency of 87 milliseconds from the official scorekeeper's API to the screen of a fan sitting in section A6. That's faster than the human visual reaction time,, and which makes the app feel aliveGeneric apps that rely on periodic HTTP polling can only promise stale data and frustrated users.

This event-driven model isn't just about performance; it's about correctness. Because every state change-like a goal being reversed-propagates as a new event, the app's UI always converges to the canonical match timeline. There's no risk of a fan seeing a cached "1-0" for 30 seconds after the goal was disallowed. For a team with HV71's legacy and passionate fanbase, data integrity during critical moments isn't a nice-to-have; it's an expectation that borders on a contractual obligation.

HV71's Digital Stack: A Blueprint for Real-Time Engagement

The HV71 platform isn't a single application; it's a family of services anchored by a real-time fan hub. The mobile client is built with Flutter, sharing 95% of its Dart code between iOS and Android while still achieving 60fps animations for live match trackers. Behind it, a Backend-for-Frontend (BFF) layer written in Kotlin and deployed on Ktor translates the raw firehose of sport data into the exact shape each screen needs. This BFF is crucial-it shields the mobile team from upstream changes in the league's data provider API, which has a habit of breaking backward compatibility midway through the season.

Data ingestion starts with a custom connector that polls the league's proprietary XML feed every 200 milliseconds. We wrote it in Rust for two reasons: memory safety under sustained load and the ability to parse malformed XML without crashing. The connector emits protobuf-encoded events to a Kafka cluster hosted on Confluent Cloud, with local mirroring into a 3-node cluster inside the arena. This dual-write strategy ensures that even if the WAN link to the cloud provider fails during a game, the in-arena systems continue to process events with sub-10ms publish latency.

Perhaps the stack's most underappreciated component is the client-side state machine. We modeled every match as a state chart using XState, with states like PMATCH_AWAY_FAN_ONLY, PENDING_CONFIRMATION, and FINAL. This formalization caught three race conditions during integration testing that would have silently corrupted the UI. When you're dealing with HV71 fans who replay controversial offside calls frame by frame, you don't want a state management "feeling"-you want mathematical guarantees.

Architecting an Event-Driven Backend for Live Sports Data

Let's zoom into the event backbone. Every HV71 match generates approximately 1. 2 million events: face-off outcomes, puck coordinates, player substitutions, penalty announcements, and even the ambient sound level decibels (used later for a fan noise meter feature). We organized Kafka topics around domain aggregates: match-events v2, player-telemetry v1, fan-interactions v1. But since versioning is critical; it allowed us to change the schema of match-events without breaking downstream consumers that were mid-upgrade.

Each topic uses 12 partitions to match the 12 cores on our broker nodes. And we configure min, and insyncreplicas=3 to survive a broker loss without data loss. The producer application (the Rust connector) uses idempotent writes and exactly-once semantics configured via Kafka transactions. This might sound like over-engineering for a hockey app. But consider a financial bet placed inside the arena: a duplicated "shot-on-goal" event could trigger an erroneous odds calculation and cost our partner sportsbook real money. Eventual consistency is fine for a leaderboard; financial stakes demand transactional integrity.

On the consumption side, we run a fleet of Kafka Streams applications that perform stateful aggregations-like calculating a player's time-on-ice in 15-second windows or detecting goal-scoring patterns for the "momentum" chart. These stream processors materialize their results into a Redis cluster, which the BFF queries using read-through caching. The entire pipeline is instrumented with Micrometer metrics exported to a central Prometheus time-series database. A single Grafana dashboard shows us the event pipeline latency at every hop, from XML poll to client delivery.

Taming the Stadium Network: Edge Compute and Wi-Fi 6E

Early in the project, we discovered that 40% of the fan complaints about slow app performance correlated with areas of the arena where Wi-Fi 5 interference from 2. 4 GHz consumer devices was worst. HV71's arena, the Husqvarna Garden, seats over 6,200 fans-a density that stresses even enterprise-grade access points. The solution was a multi-pronged upgrade: deploy Wi-Fi 6E (802. 11ax in the 6 GHz band) to reduce co-channel interference. And install three AWS Wavelength edge nodes in the arena's server room.

Wi-Fi 6E gave us 7 additional 160 MHz channels free from legacy traffic. The improved OFDMA scheduling meant the network could serve 100 simultaneous clients per access point with deterministic latency under 5ms. But raw bandwidth wasn't enough; we needed computational power close to the user. The edge nodes run a Kubernetes cluster managed by EKS Anywhere, hosting the in-arena Kafka mirror, a local Redis instance. And the authentication service that validates JWT tokens without leaving the building. During the 2024 playoffs, this edge architecture handled a peak of 5,200 concurrent client connections without dropping a single WebSocket frame.

We also added a tricky feature: video clip generation. When a fan wants to replay a goal they just witnessed, the request is routed to a local GPU node that runs ffmpeg transcoding on the fly, stitching together a 15-second clip from the arena's multi-angle camera feeds. Traditional cloud-based transcoding would add 2-3 seconds of latency; the edge node returns the clip in under 600ms. This is where edge compute stops being a buzzword and becomes a competitive advantage for fan engagement apps like HV71's.

Building a Cross-Platform Mobile Client with Flutter and BFF

Flutter was an easy call. We needed a framework that could render complex live animations-like a puck trace overlaid on a rink map-at a consistent 60fps on both high-end Samsung devices and older iPhones that some HV71 fans still carry. The Skia rendering engine, which Flutter uses, gave us pixel-level control without the bridge tax of React Native. The widget tree we built for the live tracker uses a custom CustomPainter that receives batched positional updates via a Riverpod state notifier, ensuring the UI thread never blocks on layout calculations.

The BFF pattern, mentioned earlier, deserves more detail. Our BFF is a single Ktor service. But it dynamically composes responses based on the client version and screen orientation. For example, the Android version 4. 2 of the HV71 app introduced a "seat upgrade" widget that required a different JSON structure from the ticket service. Instead of versioning the entire API, the BFF inspects an X-Client-Version header and adjusts the response shape accordingly. This decoupled the mobile release cycle from the backend-a lifesaver when Apple's review process delayed our update by two days before a critical derby match.

The client also implements offline resilience. Using a local SQLite database (via the drift package), the app caches the full season schedule, past match statistics. And even a degraded match timeline that's updated opportunistically over a background work manager. When a fan traverses a cellular dead zone entering the arena, the UI doesn't flash a spinner; it falls back to the cached state and then reconciles once the WebSocket reconnects. This "cache-first, then update" strategy is textbook progressive enhancement. But it's shocking how few sports apps add it correctly.

Optimizing Push Notification Delivery During Critical Game Moments

Push notifications are the most dangerous component of a live sports app. A "GOAL! " alert that arrives 45 seconds late is worse than no alert-it makes the app feel broken. We went through three iterations on HV71's notification pipeline before we were satisfied. The first version used Firebase Cloud Messaging (FCM) directly. But we suffered from head-of-line blocking when a large number of notifications queued up during a penalty shoot-out. The second version introduced priority queuing. But we still saw uneven delivery because FCM's upstream servers apply opaque rate limits.

Our production version now uses a multi-channel approach. For instantly actionable events (goals, final score), we bypass standard FCM and use the FCM HTTP v1 API with the apns-priority header set to 10 (immediate). For non-urgent updates (concession discounts