Rustworker.rs

use tokio::sync::mpsc;

pub struct Job {
    pub id: String,
    pub payload: Vec<u8>,
}

pub async fn consume(
    mut jobs: mpsc::Receiver<Job>,
) -> Result<(), WorkerError> {
    while let Some(job) = jobs.recv().await {
        process(&job).await?;
        checkpoint(&job.id).await?;
    }

    Ok(())
}

TypeScriptevents.ts

type Event = {
  id: string;
  topic: string;
  payload: unknown;
};

async function dispatch(event: Event) {
  const handler = handlers.get(event.topic);
  if (!handler) return;

  await handler(event.payload);
  await checkpoint.save(event.id);
}

const handlers = new Map<
  string,
  (payload: unknown) => Promise<void>
>();

C#EventProcessor.cs

public sealed class EventProcessor(
    IEventStore store,
    IEventHandler handler)
{
    public async Task RunAsync(
        CancellationToken cancellation)
    {
        await foreach (var item in
            store.ReadAsync(cancellation))
        {
            await handler.ProcessAsync(
                item, cancellation);

            await store.CheckpointAsync(
                item.Id, cancellation);
        }
    }
}

Goworker.go

func consume(
    ctx context.Context,
    jobs <-chan Job,
) error {
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        case job, ok := <-jobs:
            if !ok {
                return nil
            }
            if err := process(ctx, job); err != nil {
                return err
            }
        }
    }
}

Rustworker.rs

use tokio::sync::mpsc;

pub struct Job {
    pub id: String,
    pub payload: Vec<u8>,
}

pub async fn consume(
    mut jobs: mpsc::Receiver<Job>,
) -> Result<(), WorkerError> {
    while let Some(job) = jobs.recv().await {
        process(&job).await?;
        checkpoint(&job.id).await?;
    }

    Ok(())
}

TypeScriptevents.ts

type Event = {
  id: string;
  topic: string;
  payload: unknown;
};

async function dispatch(event: Event) {
  const handler = handlers.get(event.topic);
  if (!handler) return;

  await handler(event.payload);
  await checkpoint.save(event.id);
}

const handlers = new Map<
  string,
  (payload: unknown) => Promise<void>
>();

C#EventProcessor.cs

public sealed class EventProcessor(
    IEventStore store,
    IEventHandler handler)
{
    public async Task RunAsync(
        CancellationToken cancellation)
    {
        await foreach (var item in
            store.ReadAsync(cancellation))
        {
            await handler.ProcessAsync(
                item, cancellation);

            await store.CheckpointAsync(
                item.Id, cancellation);
        }
    }
}

Goworker.go

func consume(
    ctx context.Context,
    jobs <-chan Job,
) error {
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        case job, ok := <-jobs:
            if !ok {
                return nil
            }
            if err := process(ctx, job); err != nil {
                return err
            }
        }
    }
}

TypeScriptevents.ts

type Event = {
  id: string;
  topic: string;
  payload: unknown;
};

async function dispatch(event: Event) {
  const handler = handlers.get(event.topic);
  if (!handler) return;

  await handler(event.payload);
  await checkpoint.save(event.id);
}

const handlers = new Map<
  string,
  (payload: unknown) => Promise<void>
>();

C#EventProcessor.cs

public sealed class EventProcessor(
    IEventStore store,
    IEventHandler handler)
{
    public async Task RunAsync(
        CancellationToken cancellation)
    {
        await foreach (var item in
            store.ReadAsync(cancellation))
        {
            await handler.ProcessAsync(
                item, cancellation);

            await store.CheckpointAsync(
                item.Id, cancellation);
        }
    }
}

Goworker.go

func consume(
    ctx context.Context,
    jobs <-chan Job,
) error {
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        case job, ok := <-jobs:
            if !ok {
                return nil
            }
            if err := process(ctx, job); err != nil {
                return err
            }
        }
    }
}

Rustworker.rs

use tokio::sync::mpsc;

pub struct Job {
    pub id: String,
    pub payload: Vec<u8>,
}

pub async fn consume(
    mut jobs: mpsc::Receiver<Job>,
) -> Result<(), WorkerError> {
    while let Some(job) = jobs.recv().await {
        process(&job).await?;
        checkpoint(&job.id).await?;
    }

    Ok(())
}

TypeScriptevents.ts

type Event = {
  id: string;
  topic: string;
  payload: unknown;
};

async function dispatch(event: Event) {
  const handler = handlers.get(event.topic);
  if (!handler) return;

  await handler(event.payload);
  await checkpoint.save(event.id);
}

const handlers = new Map<
  string,
  (payload: unknown) => Promise<void>
>();

C#EventProcessor.cs

public sealed class EventProcessor(
    IEventStore store,
    IEventHandler handler)
{
    public async Task RunAsync(
        CancellationToken cancellation)
    {
        await foreach (var item in
            store.ReadAsync(cancellation))
        {
            await handler.ProcessAsync(
                item, cancellation);

            await store.CheckpointAsync(
                item.Id, cancellation);
        }
    }
}

Goworker.go

func consume(
    ctx context.Context,
    jobs <-chan Job,
) error {
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        case job, ok := <-jobs:
            if !ok {
                return nil
            }
            if err := process(ctx, job); err != nil {
                return err
            }
        }
    }
}

Rustworker.rs

use tokio::sync::mpsc;

pub struct Job {
    pub id: String,
    pub payload: Vec<u8>,
}

pub async fn consume(
    mut jobs: mpsc::Receiver<Job>,
) -> Result<(), WorkerError> {
    while let Some(job) = jobs.recv().await {
        process(&job).await?;
        checkpoint(&job.id).await?;
    }

    Ok(())
}

C#EventProcessor.cs

public sealed class EventProcessor(
    IEventStore store,
    IEventHandler handler)
{
    public async Task RunAsync(
        CancellationToken cancellation)
    {
        await foreach (var item in
            store.ReadAsync(cancellation))
        {
            await handler.ProcessAsync(
                item, cancellation);

            await store.CheckpointAsync(
                item.Id, cancellation);
        }
    }
}

Goworker.go

func consume(
    ctx context.Context,
    jobs <-chan Job,
) error {
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        case job, ok := <-jobs:
            if !ok {
                return nil
            }
            if err := process(ctx, job); err != nil {
                return err
            }
        }
    }
}

Rustworker.rs

use tokio::sync::mpsc;

pub struct Job {
    pub id: String,
    pub payload: Vec<u8>,
}

pub async fn consume(
    mut jobs: mpsc::Receiver<Job>,
) -> Result<(), WorkerError> {
    while let Some(job) = jobs.recv().await {
        process(&job).await?;
        checkpoint(&job.id).await?;
    }

    Ok(())
}

TypeScriptevents.ts

type Event = {
  id: string;
  topic: string;
  payload: unknown;
};

async function dispatch(event: Event) {
  const handler = handlers.get(event.topic);
  if (!handler) return;

  await handler(event.payload);
  await checkpoint.save(event.id);
}

const handlers = new Map<
  string,
  (payload: unknown) => Promise<void>
>();

C#EventProcessor.cs

public sealed class EventProcessor(
    IEventStore store,
    IEventHandler handler)
{
    public async Task RunAsync(
        CancellationToken cancellation)
    {
        await foreach (var item in
            store.ReadAsync(cancellation))
        {
            await handler.ProcessAsync(
                item, cancellation);

            await store.CheckpointAsync(
                item.Id, cancellation);
        }
    }
}

Goworker.go

func consume(
    ctx context.Context,
    jobs <-chan Job,
) error {
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        case job, ok := <-jobs:
            if !ok {
                return nil
            }
            if err := process(ctx, job); err != nil {
                return err
            }
        }
    }
}

Rustworker.rs

use tokio::sync::mpsc;

pub struct Job {
    pub id: String,
    pub payload: Vec<u8>,
}

pub async fn consume(
    mut jobs: mpsc::Receiver<Job>,
) -> Result<(), WorkerError> {
    while let Some(job) = jobs.recv().await {
        process(&job).await?;
        checkpoint(&job.id).await?;
    }

    Ok(())
}

TypeScriptevents.ts

type Event = {
  id: string;
  topic: string;
  payload: unknown;
};

async function dispatch(event: Event) {
  const handler = handlers.get(event.topic);
  if (!handler) return;

  await handler(event.payload);
  await checkpoint.save(event.id);
}

const handlers = new Map<
  string,
  (payload: unknown) => Promise<void>
>();

Goworker.go

func consume(
    ctx context.Context,
    jobs <-chan Job,
) error {
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        case job, ok := <-jobs:
            if !ok {
                return nil
            }
            if err := process(ctx, job); err != nil {
                return err
            }
        }
    }
}

Rustworker.rs

use tokio::sync::mpsc;

pub struct Job {
    pub id: String,
    pub payload: Vec<u8>,
}

pub async fn consume(
    mut jobs: mpsc::Receiver<Job>,
) -> Result<(), WorkerError> {
    while let Some(job) = jobs.recv().await {
        process(&job).await?;
        checkpoint(&job.id).await?;
    }

    Ok(())
}

TypeScriptevents.ts

type Event = {
  id: string;
  topic: string;
  payload: unknown;
};

async function dispatch(event: Event) {
  const handler = handlers.get(event.topic);
  if (!handler) return;

  await handler(event.payload);
  await checkpoint.save(event.id);
}

const handlers = new Map<
  string,
  (payload: unknown) => Promise<void>
>();

C#EventProcessor.cs

public sealed class EventProcessor(
    IEventStore store,
    IEventHandler handler)
{
    public async Task RunAsync(
        CancellationToken cancellation)
    {
        await foreach (var item in
            store.ReadAsync(cancellation))
        {
            await handler.ProcessAsync(
                item, cancellation);

            await store.CheckpointAsync(
                item.Id, cancellation);
        }
    }
}

Goworker.go

func consume(
    ctx context.Context,
    jobs <-chan Job,
) error {
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        case job, ok := <-jobs:
            if !ok {
                return nil
            }
            if err := process(ctx, job); err != nil {
                return err
            }
        }
    }
}

Rustworker.rs

use tokio::sync::mpsc;

pub struct Job {
    pub id: String,
    pub payload: Vec<u8>,
}

pub async fn consume(
    mut jobs: mpsc::Receiver<Job>,
) -> Result<(), WorkerError> {
    while let Some(job) = jobs.recv().await {
        process(&job).await?;
        checkpoint(&job.id).await?;
    }

    Ok(())
}

TypeScriptevents.ts

type Event = {
  id: string;
  topic: string;
  payload: unknown;
};

async function dispatch(event: Event) {
  const handler = handlers.get(event.topic);
  if (!handler) return;

  await handler(event.payload);
  await checkpoint.save(event.id);
}

const handlers = new Map<
  string,
  (payload: unknown) => Promise<void>
>();

C#EventProcessor.cs

public sealed class EventProcessor(
    IEventStore store,
    IEventHandler handler)
{
    public async Task RunAsync(
        CancellationToken cancellation)
    {
        await foreach (var item in
            store.ReadAsync(cancellation))
        {
            await handler.ProcessAsync(
                item, cancellation);

            await store.CheckpointAsync(
                item.Id, cancellation);
        }
    }
}

SOFTWARE ENGINEER & TECHNICAL LEADERSÃO PAULO / BRAZIL + CANADA

RENANTONHEIRO

Software engineering.
Technical leadership.
International experience.

Explore my work ↗

HANDS-ON ENGINEER / EXPERIENCED LEADER

Engineering& leadership.

From architecture and production systems to managing distributed teams.

AlwaysGeeky GamesPreviously Ubisoft

01 / BACKGROUNDPEOPLE, PRODUCTS & PLACES

BRAZILIAN & CANADIAN CITIZEN

Brazil. Canada.
A global perspective.

My career took me from São Paulo to Brossard and Montréal. Living and working in Canada, alongside my experience in Brazil, gave me first-hand experience of different working cultures and international collaboration.

Portuguese: Native
English: Fluent
French: Intermediate

02 / SELECTED WORK

Engineering in practice.

UBISOFT2018 — 2022

Remote leadershipArchitectureHiringDelivery strategy

CASE STUDY / 01

Engineering management & technical leadership

Managed remote developers across countries, set technical direction, and aligned engineering delivery with product and business priorities. Supported teams through hiring, shared standards, and hands-on architecture.

UBISOFT2015 — 2022

Distributed systems.NETReactTechnical leadership

CASE STUDY / 02

Global player platforms

Built applications reaching millions of users around the world: promotional code redemption, game communities, and player support. Turned campaign-specific solutions into reusable platforms across Ubisoft.

ALWAYSGEEKY GAMES2022 — PRESENT

TypeScriptCloudflare WorkersPrismaRedis

CASE STUDY / 03

Live game backend

Designed and operated the backend behind a live game. Enabled designers to manage the experience independently and led a critical production migration without interrupting players or payments.

PERSONAL PROJECTS / GITHUB

Open source.

Desktop tools, Linux integrations, and a .NET library.
Projects I build and adapt outside my day-to-day work.

github.com/renanmt

DESKTOP INTERACTION

Switch Magic

A visual window and workspace switcher for Omarchy. Live previews, keyboard navigation, and a view studio for customizing layouts and motion.

QML
Quickshell
Hyprland

View source

MULTI-MONITOR TOOLS

Wallpaper Cutter

Compose one wallpaper across multiple displays. Live crop previews, bezel compensation, and saved alignment handle mixed orientations and screen scaling.

Python
QML
ImageMagick

View source

NATIVE LINUX APPLICATIONS

eXorchy

An Omarchy adaptation of Exodium’s retro-game launcher. Native GTK4, live desktop theming, and Arch packaging bring the eXo collections to the Omarchy desktop.

Based on Exodium by Thomas Vollstädt.

Rust
GTK4
libadwaita

View source

SYSTEMS & HARDWARE

Linux Flux Pro

A Rust daemon that connects Linux temperature sensors to the Antec Flux Pro’s display over USB HID, with direct NVIDIA NVML access and systemd integration.

Rust
USB HID
NVML
systemd

View source

.NET DATA ACCESS

Dapper.Apex

A C# extension library for Dapper with synchronous and asynchronous CRUD operations, composite keys, and entity mapping for SQL Server and MySQL.

C#
.NET
Dapper
SQL

View source

04 / TECHNOLOGIES

What I work with.

My open-source projects span Rust, Go, and Python. Experience across languages, platforms, and teams helps me become productive quickly in unfamiliar codebases and technology stacks.

BACKEND ENGINEERING

TypeScript · C#

Distributed systems, transactions, and application architecture.

Node.js.NETSQLPrisma

CLOUD & DATA

Cloudflare · AWS

Production operations, data access, and deployment automation.

PostgreSQLMySQLRedisDocker

WEB & DEVELOPER TOOLS

React · Svelte

Web applications, internal tooling, and shared frameworks.

JavaScriptSvelteKitCI/CDTesting

05 / CAREER2003 — PRESENT

My career,
in context.

From São Paulo to Montréal. From individual contributor to technical lead and development manager.

Jun 2022 — PresentMontréal · Remote from Brazil

AlwaysGeeky Games

Game platforms

Jun 2022 — Present
Senior Backend Engineer
Sole backend architect, responsible for the platform from domain design through production. Built transaction and progression systems and gave designers tools to manage the live game without engineering intervention.

Selected achievements +

Technical scope: a 54,000-line TypeScript backend, a 34,000-line test suite, six microservices, and 124 database models serving 64,000 players.
Removed three chain dependencies in five days with zero outages.
Built a 176-route operations dashboard with role-based access and dual authorization for balance changes.

TypeScriptCloudflare WorkersPrismaRedisSvelteKit

May 2015 — Jun 2022Montréal, Canada

Ubisoft

Global web platforms

Sep 2020 — Jun 2022
Development Manager
Managed remote developers across countries while retaining technical leadership. Connected architecture and delivery roadmaps to business priorities, coordinating with product teams, QA, and executives across locations.
May 2018 — Sep 2020
Technical Lead
Set architecture, engineering standards, and technical direction for global web projects reaching millions of users. Built shared tooling and deployment practices that teams across Ubisoft could adopt.
May 2015 — May 2018
Senior Developer
Launched the global Code Redeem Platform and shipped the community platform for Assassin’s Creed Origins.

Selected achievements +

Managed three teams totaling 11 developers across junior, intermediate, and senior levels.
Established the technical interview process behind 30+ hires across Canada, the US, France, and Romania.
Created Daileon, the React framework powering every new Ubisoft website from January 2019; adopted by teams across the company.
Worked directly with business and executive groups in Cary and San Francisco on requirements and delivery strategy.
Delivered Gameplan, Help Content Service, and Glass for player engagement and support.

React.NETAWSArchitectureTeam leadership

May 2012 — May 2015Brossard, Canada

LumaPix

Photography SaaS

May 2012 — May 2015
Senior Developer
Architected high-availability image ingestion and multi-tenant configuration services with inheritance and cascading updates.

Selected achievements +

Built cloud services for professional photography applications, including image and photobook project processing.

C#Node.jsAWSRedisMongoDB

Oct 2009 — Feb 2012São Paulo, Brazil

Citi

Financial systems

Oct 2009 — Feb 2012
Senior Analyst Developer
Modernized legacy Forex, stock options, ledger, and billing systems into web applications for VIP clients. Coordinated requirements across Brazil, the US, and India.

Selected achievements +

Winner of the DIFNER Global Contest 2010 for a shared data-access framework.
Twice recognized as Developer of the Month.

C#ASP.NETSQL ServerWCF

Aug 2007 — Sep 2009São Paulo, Brazil

Sprint Nextel

Telecommunications

Aug 2007 — Sep 2009
IT Consultant / Senior Developer
Built backend location and billing services for carrier data solutions across Brazil, Argentina, and Mexico, including GPS tracking and SMS gateway services.

Selected achievements +

Worked with regional carrier teams and Motorola on highly available mobile services.

C#JavaSQL ServerOracle

Mar 2006 — Aug 2007São Paulo, Brazil

TMS Call Center

Contact center systems

Dec 2006 — Aug 2007
Development Manager
Led the development team, redesigned delivery processes, and worked directly with clients on new systems and maintenance.
Mar 2006 — Dec 2006
Lead Developer
Developed contact center applications, including Disque Denuncia, connecting anonymous tip reporting to police stations.

Selected achievements +

Later consulted on the deployment of the 181 Disque Denuncia service in Minas Gerais (Aug–Oct 2007).

Application developmentTeam leadership

Apr 2003 — Feb 2006São Paulo, Brazil

Early career

Business applications

May 2004 — Feb 2006
Analyst Programmer / Consultant
Consulting roles at Fast Track, BMI, Grupo Ultra, WA Consulting, and FastLine Contact Center.
Apr 2003 — May 2004
Analyst Programmer · TT&S Telecom
Started in software development building client/server applications.

Client/server applicationsSystems analysis

EDUCATION

Bachelor’s, Database Systems · IBTA, São Paulo
Technical Diploma, IT / Data Processing · FITO, Osasco

CONTACT / WHAT’S NEXT

Let’s talk↗

Engineering roles.
Technical leadership.
International teams.

renan.tonheiro@gmail.com↗

GitHub ↗LinkedIn ↗Download résumé ↓Brazilian & Canadian citizen

RENANTONHEIRO

Engineering& leadership.

Brazil. Canada.A global perspective.

Engineering in practice.

Engineering management & technical leadership

Global player platforms

Live game backend

Switch Magic

Wallpaper Cutter

eXorchy

Linux Flux Pro

Dapper.Apex

What I work with.

TypeScript · C#

Cloudflare · AWS

React · Svelte

My career,in context.

AlwaysGeeky Games

Senior Backend Engineer

Ubisoft

Development Manager

Technical Lead

Senior Developer

LumaPix

Senior Developer

Citi

Senior Analyst Developer

Sprint Nextel

IT Consultant / Senior Developer

TMS Call Center

Development Manager

Lead Developer

Early career

Analyst Programmer / Consultant

Analyst Programmer · TT&S Telecom

Let’s talk↗

Brazil. Canada.
A global perspective.

My career,
in context.