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