Franco Rosatto - Senior Game Developer & Technical Leader

About

Building scalable multiplayer games

I've been making games for over 10 years, mostly with Unity and C#. Currently Tech Lead at Trick Studio, where I work on games like Stumble Guys (100M+ downloads) and Lil Snack.

What I love most is building systems that work at scale-multiplayer networking that doesn't lag, backend infrastructure that stays up, and gameplay code that runs smoothly on any device. I've shipped games for big names like Scopely, Netflix, and Amazon.

These days I'm really into Unity's ECS/DOTS and performance optimization. There's something satisfying about making a game run at 60fps with thousands of entities on screen, or cutting load times in half with better architecture.

Experience

Leading game development teams

Software Engineer

Trick Studio - Lil Snack (Scattergories)

May 2025 - Present · 10 months 🌍 Remote

Lil Snack: New pop-culture games & puzzles every day!
https://www.lilsnack.co

Software Engineer - Scattergories
Contributing to the design, development, and maintenance of core product features. Focused on building scalable, high-performance, and maintainable systems for daily puzzle games.

Collaborate closely with product and design teams to turn game rules and ideas into reliable technical solutions
Improve user experience through performant UI systems and smooth gameplay mechanics
Optimize existing workflows to support rapid content delivery (daily puzzles)
Resolve complex bugs while supporting long-term product evolution
Implement analytics and telemetry systems to track player behavior and retention

Unity C# Software Design Game Infrastructure

Tech Lead

Trick Studio - Stumble Guys

Oct 2023 - May 2025 · 1 year 8 months 🌍 Remote

Stumble Guys: Massive multiplayer battle royale with 100M+ downloads
https://www.stumbleguys.com/es

Tech Lead - Stumble Guys
Led engineering efforts for one of the most successful multiplayer mobile games globally, managing core gameplay systems and platform features at massive scale.

Led cross-functional teams of 8-12 developers in an agile environment
Designed and implemented scalable real-time multiplayer systems supporting 32+ concurrent players per match
Architected client-server systems with authoritative servers, lag compensation, and prediction
Optimized performance for mobile platforms (iOS/Android) achieving 60fps on mid-tier devices
Built LiveOps infrastructure for events, seasons, and content updates without client releases
Implemented backend integration with game servers, analytics, and monetization systems
Established code review processes, coding standards, and CI/CD pipelines
Mentored junior and mid-level engineers, improving team velocity and code quality

Unity3D C# .NET Core Tech Leadership Multiplayer

Tech Lead

Trick Studio

Jan 2023 - Oct 2023 · 10 months 🌍 Remote

Technical leadership across multiple game projects, focusing on architecture, team management, and infrastructure.

Led technical architecture decisions for new game prototypes and features
Managed technical personnel and coordinated sprint planning
Implemented LiveOps systems for dynamic content delivery and player engagement
Integrated SmartFox Server for real-time multiplayer networking
Built backend services using Node.js and Java microservices
Established development workflows and quality assurance processes

Unity3D Node.js Java SmartFox LiveOps Team Management

Tech Lead

Trick Studio - Internal Projects

Jun 2022 - Oct 2023 · 1 year 5 months

Led engineering teams through full project lifecycles
Designed system architecture for scalability and maintainability
Implemented database solutions with SQL and Entity Framework
Built ASP.NET Core backend services with RESTful APIs
Established Git workflows and version control best practices
Fostered team collaboration and technical excellence

Unity3D ASP.NET Core SQL Entity Framework System Architecture Team Leadership

Game Development

Expert-level Unity and C# development

Building Games at Scale

I work on multiplayer games that need to handle millions of players. Stumble Guys taught me a lot about what happens when your game suddenly hits 100M downloads-you learn real quick what "scale" actually means. These days I focus on writing code that's both fun to work with and actually performs well in production.

Unity Engine Mastery

10+ years of Unity development experience

Advanced Gameplay: Built complex systems like deterministic physics for replays, procedural level generation with seed-based algorithms, and AI using utility-based decision making combined with behavior trees. I've optimized pathfinding with A* variants and navigation mesh baking at runtime.
Performance Deep Dive: I profile everything. Cut draw calls from 1200 to 400 using static/dynamic batching and GPU instancing. Managed memory pools for 50,000+ objects. Used LOD systems with custom transition zones. Implemented occlusion culling strategies beyond Unity's defaults.
Mobile Mastery: Shipped games running 60fps on devices with 2GB RAM. Texture compression (ASTC, ETC2), mesh decimation, shader LODs, and custom render pipelines for mobile. Profiled every frame to eliminate GC spikes. Built asset streaming systems for large open worlds.
Editor Wizardry: Created custom inspectors, property drawers, and scene tools. Built automated asset processors that run on import. Made level design tools that non-programmers actually enjoy using. ScriptableObject-based data pipelines for game balance.

Advanced Performance & Graphics

Cutting-edge Unity technologies for maximum performance

Custom Shaders: I write HLSL shaders that push visual quality while staying performant. Built custom lighting models, toon shaders with multiple ramp textures, water with caustics and refraction, and volumetric fog. I optimize shader variants to avoid build bloat (seen projects with 50k+ variants crash).
Compute Shaders: When CPUs can't keep up, GPUs save the day. I've offloaded particle physics (100k+ particles), procedural mesh generation, and even game logic to compute shaders. Wrote fluid simulation running entirely on GPU. 10x faster than CPU and it freed up threads for other work.
ECS/DOTS Expertise: Built production systems with Unity DOTS. Handled 10,000+ entities at 60fps with proper chunk iteration and job dependencies. The trick is data layout. AoS vs SoA makes huge differences. I use Burst Inspector to verify SIMD code generation.
Burst Optimization: I read assembly output. Seriously. When you need every cycle, you check if Burst vectorized your loops. Used SharedStatic for lookup tables, marked functions with [BurstCompile], and avoided managed references. Got physics running 15x faster than MonoBehaviour version.
Job System Mastery: Parallelized everything possible. Pathfinding for 1000 agents runs in parallel jobs. Animation blending, raycasts, physics queries... all jobified. The key is avoiding race conditions with NativeContainers and understanding job dependencies.
Custom Render Pipelines: Wrote custom SRP for mobile with tiled deferred rendering. Built forward+ renderer for VR. Implemented clustered lighting supporting 200+ dynamic lights. Each platform needs different strategies. Console vs mobile vs PC are completely different beasts.

C# & Software Design Patterns

Expert-level C# programming and architecture

Design Patterns: Use patterns when they solve real problems. Not a fan of pattern-for-pattern's-sake code. Object pooling is mandatory for mobile. Command pattern for input and replays. State machines for player controllers. Observer for UI updates. Factory for spawning. Keep it simple.
SOLID in Practice: Write code others can read. Single Responsibility keeps classes focused. Open/Closed through inheritance and composition. Interface Segregation prevents bloated interfaces. Dependency Inversion with DI containers. Real projects need this or they become unmaintainable.
Event Systems: Built event-driven architectures that scale. Custom event bus for game-wide messaging. ScriptableObject events for designer-friendly workflows. UnityEvents for inspector hookups. The right tool for the right job. Performance matters so I avoid boxing and use structs for event data.
Dependency Injection: Zenject/Extenject for larger projects. Keeps dependencies explicit and testable. No more singleton hell. Easy to swap implementations. Testing becomes possible. Set up contexts for different game modes.
Modern C# (Async/Await): Tasks and async/await changed everything. Load assets async without blocking. Network calls don't freeze the game. UniTask for Unity-specific async. Cancellation tokens for cleanup. Understanding synchronization contexts is critical.
Memory Optimization: I know when GC runs and why. Value types vs reference types matter. Struct for small data, class for larger. Avoid boxing. Use ArrayPool and object pooling. Profile with Memory Profiler to catch leaks. Seen games crash from 2GB memory on mobile because of unmanaged leaks.
Unit Testing: TDD when it makes sense. NUnit for core logic. Unity Test Framework for integration. Mock systems for testing in isolation. Tests catch regressions before players do. Not everything needs tests but critical systems absolutely do.

Multiplayer & Networking

Real-time multiplayer systems at massive scale

Network Architecture: Built authoritative server systems for competitive games. Client-server for FPS, P2P for co-op. Each has trade-offs. Server authority prevents cheating but adds latency. I've implemented hybrid approaches where server validates critical actions but trusts clients for movement prediction.
Photon at Scale: Used Photon PUN for 32-player battles, Fusion for physics-based games with rollback, Quantum for deterministic lockstep (fighting games). Each engine solves different problems. Quantum's deterministic simulation lets you replay matches from input logs alone.
Custom Protocols: Written raw TCP/UDP networking in C#. TCP for reliability (chat, progression), UDP for speed (player positions). Built custom serialization that's 3x smaller than default. Every byte counts when you're sending 20 updates per second to 32 players.
State Sync Techniques: Delta compression sends only what changed. Interpolation smooths between snapshots. Extrapolation predicts future positions. I've tuned these per game. Racing games need aggressive extrapolation. Shooters need tight interpolation windows for accuracy.
Lag Compensation: Client-side prediction makes your game feel responsive. Server reconciliation corrects when predictions were wrong. Rollback/rewind for competitive fairness. I've built systems where server rewinds game state to validate if that shot actually hit based on client's ping.
Matchmaking Systems: Skill-based rating (Elo/TrueSkill), region locks, party support. Built matchmaker that fills 60-player lobbies in under 30 seconds. Queues, backfill, skill tolerance that widens over time. Edge cases like high-skill players in low-pop regions need special handling.
Real-time Communication: WebSockets for chat and live events. SignalR for bi-directional RPC. Built notification systems that push to millions of connected clients. The trick is connection pooling and efficient message routing. One server can handle 10k+ concurrent connections.
Bandwidth Optimization: Cut network traffic from 250KB/s to 80KB/s per player. Bitpacking, quantization (16-bit positions instead of 32-bit floats), update frequency scaling based on importance. Players 100m away don't need 20Hz updates. Send them at 5Hz. Your bandwidth budget thanks you.

UI/UX Development

Creating intuitive, performant user interfaces

UGUI Mastery: Expert with Unity's UI system, canvas optimization, and render modes
Custom UI Frameworks: Built reusable UI systems with data binding and MVVM patterns
Animations & Transitions: Smooth UI animations using DOTween and Unity Animation
Responsive Design: Multi-resolution support with Canvas Scaler and aspect ratio handling
Localization: Implemented multi-language support with dynamic text replacement
Accessibility: Considered colorblind modes, text scaling, and input remapping
UI Performance: Optimized for mobile with sprite atlases, batching, and minimal overdraw

Game Systems & Architecture

Scalable, maintainable game architectures

Modular Architecture: Design games as independent, testable systems/modules
Economy Systems: Virtual currency, inventory, crafting, and progression systems
Save Systems: Local and cloud save with versioning, migration, and conflict resolution
Analytics Integration: Tracking player behavior, funnels, and KPIs (Unity Analytics, Firebase)
LiveOps: A/B testing, feature flags, remote config, and event systems for continuous updates
Procedural Generation: Algorithms for levels, terrain, and content generation
AI & Pathfinding: Behavior trees, finite state machines, and NavMesh for NPC behaviors

Multi-Platform Development

Ship games across all major platforms

Mobile (iOS/Android): Platform-specific optimizations, touch controls, and store integration
WebGL: Browser-based games with JavaScript interop and Web Audio API integration
Desktop (PC/Mac): Standalone builds with Steam integration and platform services
Console: Understanding of console development workflows and requirements
Cross-Platform: Input abstraction, resolution handling, and platform-specific features
Build Automation: CI/CD pipelines for automated builds across all platforms

 Notable Achievements
                  Stumble Guys: Working on a game with 100M+ downloads was surreal. Watching millions of people play something you helped build never gets old.
Mobile Performance: Getting 60fps on a phone with 2GB RAM isn't easy, but it's doable. Memory management becomes second nature after a while.
Multiplayer: 32+ players in a match with under 100ms latency. The trick is knowing what to send and when.
ECS: Built a system handling 10,000+ entities at 60fps using Unity's DOTS. Watching that frame counter stay green was incredibly satisfying.

                

                  LiveOps: Set up a system that lets us push weekly events without updating the app. Players get new content, we don't wait for app store approval. Win-win.
Asset Store: Published 3 tools on Unity's Asset Store. Thousands of developers use them, which is pretty cool.
Shader Magic: Cut GPU overhead by 40% through shader tweaks and better batching. Sometimes the best optimizations are the subtle ones.
GPU Power: Moved particle systems to compute shaders-10x faster. The GPU was just sitting there waiting to help.
Burst Speed: Unity's Burst compiler is wild. CPU code running at near-C++ speeds. Game development in 2024 is pretty amazing.

                

Engineering & Architecture

Scalable systems and infrastructure

Building Software That Lasts

Good code is one thing. Code that scales to millions of users? That's where architecture matters. I've learned this the hard way-when your game blows up overnight, you find out real quick if your systems can handle it. These days I think a lot about making things both flexible for future changes and simple enough that the team can actually work with it.

System Architecture & Design

Microservices Architecture: Designed distributed systems with independent services for auth, matchmaking, economy, chat, and analytics
Event-Driven Systems: Message queues (RabbitMQ, AWS SQS) for asynchronous processing and service decoupling
API Design: RESTful and GraphQL APIs with versioning, documentation (Swagger), and rate limiting
Monolith to Microservices: Successfully migrated legacy monoliths to service-oriented architectures
CQRS & Event Sourcing: Implemented for complex domains requiring audit trails and scalability
Domain-Driven Design: Model complex game logic with bounded contexts and aggregates

Cloud Infrastructure & DevOps

AWS Services: EC2, S3, Lambda, DynamoDB, RDS, ElastiCache, CloudFront, SQS, SNS
Azure: App Services, Azure Functions, Cosmos DB, Application Insights
Containerization: Docker containers for consistent dev/prod environments
Orchestration: Kubernetes for container orchestration and auto-scaling
CI/CD Pipelines: Jenkins, GitHub Actions, GitLab CI for automated testing and deployment
Infrastructure as Code: Terraform and CloudFormation for reproducible infrastructure
Monitoring: ELK stack, Application Insights, Grafana for observability and alerting

Backend Development

.NET Core / ASP.NET: Building high-performance web APIs and services
Entity Framework: ORM for database access with migrations and relationships
Dapper: Micro-ORM for performance-critical queries
Node.js: Real-time services and WebSocket servers
Authentication: OAuth2, JWT, OpenID Connect for secure user authentication
Caching Strategies: Redis, in-memory caching for performance
Queue Processing: Background workers for async tasks (Hangfire, Azure Functions)

Database & Data Management

SQL Databases: SQL Server, MySQL, PostgreSQL for relational data
NoSQL: MongoDB for flexible schemas, DynamoDB for key-value storage
Database Design: Normalization, indexing, query optimization, and partitioning
Migrations: Schema versioning and zero-downtime migrations
Replication: Master-slave setups for read scalability
Backup & Recovery: Automated backups with point-in-time recovery
Data Analytics: ETL pipelines for business intelligence and player insights

Code Quality & Testing

Clean Code: Follow Robert C. Martin's principles for readable, maintainable code
SOLID Principles: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion
Code Reviews: Established peer review processes with clear guidelines
Unit Testing: NUnit, xUnit with high test coverage for critical paths
Integration Testing: Test service interactions and database operations
TDD: Test-Driven Development for complex business logic
Refactoring: Continuous improvement without breaking existing functionality

Enterprise Software & Processes

Agile/Scrum: Sprint planning, daily standups, retrospectives, and iterative development
JIRA/Confluence: Project management, task tracking, and documentation
Git Workflows: Feature branching, pull requests, and merge strategies (Git Flow)
Documentation: Technical specs, API docs, architecture decision records (ADRs)
Security: OWASP best practices, SQL injection prevention, encryption, secure storage
Compliance: GDPR, data privacy, and player data protection
Performance Tuning: Profiling, bottleneck identification, and optimization

How I Think About Code

I try to write code that solves today's problem without painting myself into a corner for tomorrow. It's tempting to build this perfect, infinitely scalable system, but honestly? That's usually a waste of time. The trick is finding the middle ground-code that's simple enough that anyone on the team can understand it, but solid enough that it won't fall apart when things get busy.

Every decision is a trade-off. "Should we use microservices here?" depends on a dozen factors. I've learned to document why I made a choice, because future me (and future teammates) will definitely ask. And I'm always ready to change direction when the real world tells me I was wrong. Good architecture isn't dogmatic-it adapts.