Philip Scheer

Projects & Case Studies

Selected projects that show how I connect architecture decisions to business outcomes.

10x scale, half the cost

Real-Time Sports Data Platform

Context

A real-time sports data platform (web, mobile and live services) needed to grow from 100K to over 1M concurrent users without exploding infrastructure spend.

Challenge

Sustain sub-300ms P99 latency under 10x traffic growth while keeping operating cost viable for the business.

My role

Engineering & Architecture Lead — owning the technical roadmap, architecture and delivery across squads.

Solution

Architected a real-time backbone: Python/FastAPI hub, gRPC/Protobuf dataloader, Redis pub/sub and Go WebSocket fan-out & push services. Standardized a polyglot microservices stack with a Figma-aligned design system for web (Next.js/React) and mobile (Flutter).

Impact

  • Scaled 10x: 100K → 1M+ concurrent users
  • Sub-300ms P99 latency sustained
  • ~57% lower operating cost (≈2.3x cheaper)

Stack & practices

Python/FastAPIGogRPC/ProtobufRedis pub/subPostgreSQLBullMQDockerPrometheusNext.js/ReactFlutter

Key learnings

Architecture is the most powerful FinOps tool: the cheapest infrastructure is the one your design no longer needs.

Resilience engineering at fan-out scale

Push Notification Platform for 500K+ Users

Context

A sports platform needed to deliver push notifications for live match events to hundreds of thousands of devices within seconds — with traffic spiking at every goal.

Challenge

Handle burst loads of thousands of events per second, duplicated upstream signals and third-party throttling (SNS/FCM/APNs) without missed or duplicate notifications.

My role

Architecture and engineering lead for the notifications backend.

Solution

Go/gRPC service with a 100-worker processing pool; distributed deduplication using Redis Lua scripts; circuit breaker on the SNS integration; adaptive rate limiting with automatic backoff; batch publishing (10 messages per API call); Prometheus metrics end to end and graceful shutdown for safe deploys.

Impact

  • Designed and validated for 500K+ concurrent users
  • 5,000+ events/second processed per instance
  • 10x fewer SNS API calls through batch publishing
  • Duplicate-free delivery under burst load

Stack & practices

GogRPC/ProtobufRedis clusterPostgreSQL (pgx)AWS SNS → FCM/APNsPrometheusDocker/ECS

Key learnings

At fan-out scale, resilience patterns — deduplication, circuit breaking, adaptive backoff — are not extras. They are the product.

800+ teams, 12 companies, 2,000+ products

Dell Design System at Enterprise Scale

Context

Dell Technologies needed UX consistency and development efficiency across one of the largest product portfolios in tech — spanning multiple business units, brands and e-commerce operations.

Challenge

Build and govern a single design system serving hundreds of teams without becoming a bottleneck: components, standards, documentation, tooling and — hardest of all — adoption at enterprise scale.

My role

Design System Manager (2020–2022) — vision, roadmap, governance and delivery, working fully remote across US and Brazil teams.

Solution

Built and governed the Dell Design System (delldesignsystem.com): component standards, design tokens, documentation and tooling, with incremental agile delivery and a contribution model that let product teams extend the system instead of forking it.

Impact

  • 800+ teams across 12 companies using DDS as their primary framework
  • 2,000+ products built on the system
  • Higher e-commerce reliability through consistent, tested components
  • Lower development cost through reuse at scale

Stack & practices

Design systemsDesign tokensComponent librariesDocumentation toolingGovernanceAgile delivery

Key learnings

A design system at enterprise scale is a product with customers — adoption is earned through reliability and developer experience, not mandates.

Spend predictability as an engineering discipline

Cloud Cost Optimization & FinOps Governance

Context

A technology operation needed to reduce cloud spend, improve predictability and bring governance to a grown-organically AWS environment.

Challenge

Cut cost without harming reliability or delivery speed — and make spend visible and predictable for the business.

My role

Technology leader driving FinOps practices, architecture review and cloud governance.

Solution

Workload-by-workload review, right-sizing and architecture adjustments; observability and cost monitoring; FinOps rituals connecting engineering decisions to financial outcomes.

Impact

  • ~30% reduction in AWS costs
  • Additional 20% optimization plan mapped
  • Improved governance, observability and spend predictability

Stack & practices

AWSFinOpsObservabilityCloud architecture reviewMonitoring

Key learnings

Cost optimization is continuous, not a one-off project. Visibility comes first; savings follow.

One codebase, two platforms, 700+ builds shipped

Cross-Platform Mobile App at Production Maturity

Context

A sports product needed iOS and Android apps with live real-time data, payments and rich content — evolving weekly without doubling the team.

Challenge

Real-time updates over unreliable mobile networks, in-app purchases compliant with both stores, and a modular architecture that keeps a fast-growing codebase healthy.

My role

Engineering leadership for the mobile platform and its architecture.

Solution

Flutter app structured as 10+ internal packages (authentication, push, deep links, core, preferences); BLoC pattern for state; Protobuf over WebSockets for live match data; Firebase for analytics, crash reporting and auth; multi-flavor builds per environment; conventional commits and git hooks enforcing release discipline.

Impact

  • Single codebase serving iOS and Android
  • 700+ builds shipped — weekly release cadence sustained
  • Live match data streaming inside the app
  • Modular packages enabling parallel team workstreams

Stack & practices

Flutter/DartBLoCProtobuf/WebSocketsgRPCFirebaseIn-app purchasesCI/CD

Key learnings

Mobile scale problems are organizational before they are technical: modular boundaries and release discipline are what keep weekly shipping sustainable.

Money flows demand auditable engineering

Affiliate Platform with Financial Governance

Context

An affiliate network needed a platform to manage partners, commissions, campaign analytics and payment cycles — where every cent must be traceable.

Challenge

Financial correctness under concurrency, abuse detection, LGPD compliance and full auditability — without slowing product delivery.

My role

Architecture and delivery leadership for the platform.

Solution

NestJS + React monorepo over Prisma/PostgreSQL; payment cycles modeled as an explicit state machine; async processing with Redis/Bull queues; BigQuery sync for analytics; audit trail with request context; PII masking, role-based access control and a partner-facing API gateway; Stripe integration for payouts.

Impact

  • End-to-end auditable financial flows with explicit payment-cycle states
  • CPA abuse detection with automated adjustments
  • LGPD compliance by design (PII masking, consent, retention)
  • Analytics decoupled to BigQuery without touching transactional load

Stack & practices

NestJSReactTypeScriptPrisma/PostgreSQLBigQueryRedis/BullStripeJest/Vitest/Playwright

Key learnings

In financial systems, the state machine is the specification — if a money state is not explicit in code, it will eventually be implicit in a spreadsheet.

3M+ users, engagement-driven evolution

High-Volume Digital Product Platform

Context

A digital product with millions of users, subscriptions, payment integration and continuous demand for product evolution.

Challenge

Keep a large user base engaged while coordinating engineering, product, data and business priorities in a single technical roadmap.

My role

Technology manager coordinating engineering, product, data and business teams.

Solution

Structured the technical roadmap around engagement metrics and product data; streamlined payment integrations; established a delivery cadence connecting product discovery to engineering execution.

Impact

  • 3M+ user base served
  • Continuous product evolution with measurable engagement gains
  • Tighter alignment between engineering, product, data and business

Stack & practices

Product analyticsPayments integrationEngagement metricsTechnical roadmap

Key learnings

At scale, product decisions are data decisions — the roadmap must be anchored on metrics everyone trusts.

Conversational ordering connected to real inventory

Order Chatbot & Commercial Automation

Context

A commercial operation needed a chatbot able to take orders against live catalog, pricing and stock data.

Challenge

Match free-text customer requests to real SKUs reliably — with messy product names, validation needs and full operational traceability.

My role

Architecture and delivery lead for the conversational ordering flow.

Solution

Integrated product, pricing and stock bases via APIs over PostgreSQL; combined fuzzy search algorithms with GPT-based interpretation; SKU/EAN validation, error handling and observability across the funnel.

Impact

  • Faster, leaner commercial ordering flow
  • Fewer order errors through SKU/EAN validation
  • Operational visibility end to end

Stack & practices

PostgreSQLAPIsFuzzy searchGPT/LLM integrationSKU/EAN validationObservability

Key learnings

LLMs shine when wrapped in deterministic guardrails: search, validation and observability turn a demo into a product.

LLM vision with production guardrails

AI Document Analysis & Distribution at Scale

Context

A commercial operation processed thousands of user-submitted images per day that needed validation, classification and routing to messaging channels.

Challenge

Sustain throughput and control cost on LLM/OCR analysis while respecting messaging-platform rate limits — with zero tolerance for duplicate sends.

My role

Architecture and delivery lead for the automation pipeline.

Solution

OpenAI Vision pipeline with a 48-worker analysis pool and large-batch processing; separate 24-worker media pipeline; global and per-chat rate limiting for Telegram distribution; deduplication window; cloud storage for media; admin panel for operations.

Impact

  • Thousands of images triaged automatically per day
  • API spend controlled through batching and caching
  • Stable distribution under burst load, duplicate-free

Stack & practices

Python/FlaskOpenAI VisionTelegram APISupabaseWorker poolsRate limiting

Key learnings

LLMs in production are a throughput-and-guardrails problem: the model is 20% of the system, the engineering around it is the other 80%.

Connecting LLMs to real systems, safely

MCP & Agentic Tooling for Engineering Operations

Context

Daily engineering routines — standups, work-item planning, branching, changelogs, quality checks, PR creation, document and data analysis — consumed senior engineering time across Azure DevOps, GitHub and internal systems.

Challenge

Give LLM agents real access to production tooling without giving up governance, traceability or quality standards.

My role

Designed and built the agentic tooling and its operating model.

Solution

MCP-based skills connecting Claude to Azure DevOps and GitHub: automated standup digests, work-item planning with approval gates, branch and changelog conventions, enforced quality gates (lint, type-check, tests, secret scanning, conventional commits) and PR creation with AI self-review. The same pattern extended to OCR and data-analysis pipelines with human approval before any write.

Impact

  • Daily engineering routine automated end to end
  • Quality gates enforced on every AI-assisted change
  • One agentic pattern reused across DevOps, OCR and data analysis

Stack & practices

MCPClaude / LLMsAzure DevOps APIGitHub CLIQuality gatesPython/TypeScript

Key learnings

Agents are only as safe as the tools you hand them — MCP turns governance from a policy document into executable code.

From ad-hoc delivery to predictable engineering

Technical Governance & Roadmap Structuring

Context

A growing organization needed structure: squads, backlog discipline, architecture governance and a roadmap stakeholders could trust.

Challenge

Bring predictability and quality without burying teams in process.

My role

Technology leader designing the operating model for engineering.

Solution

Organized squads with clear missions; biweekly cadence for review and prioritization; engineering indicators; Architecture Review Boards and standardized processes from refinement to release.

Impact

  • Predictable delivery cadence with measurable quality
  • Stakeholders aligned around a single prioritized roadmap
  • Architecture decisions documented and auditable

Stack & practices

Squad designTechnical roadmapEngineering metricsADRs/RFCsStakeholder management

Key learnings

Governance is what you remove as much as what you add — every ritual must pay for itself in clarity.

From transactional data to executive decisions

Data, BI & Analytics Integration

Context

Decision-makers needed trustworthy indicators, but data lived scattered across transactional systems.

Challenge

Integrate data continuously and reliably, with quality guarantees, into analytics that support real decisions.

My role

Technology leader for the data integration and analytics initiative.

Solution

30 Airflow DAGs orchestrating ingestion from 8+ sources — partner platforms, ERP, marketing and project-management APIs — into PostgreSQL and BigQuery, with CDC where applicable; 8 dbt projects modeling business views; idempotent, conflict-safe loads and pipeline alerting via Telegram.

Impact

  • 30 production DAGs integrating 8+ data sources
  • 8 dbt projects powering modeled business views
  • Decision-making anchored on a single source of truth
  • Data quality monitored, not assumed

Stack & practices

AirflowdbtBigQueryCDCPostgreSQLData governance

Key learnings

BI fails on trust before it fails on tech — governance and data quality are what make dashboards matter.