Senior Fullstack Engineer / Tech Lead

Engineering the architecture behind your next phase of growth.

15+ years across Fintech, Edtech & Healthtech. I assess the legacy system, decide the architecture, review the code, and lead the team that ships it. Clean architecture, hands-on.

Available for remote / hybrid roles · Rio de Janeiro, Brazil · English B2

Portrait of Vinicius Cruz
Available for hire
15+Years experience
−83%Infra cost cut
16×Faster API response
10×Paid user growth
01 — About

Architecture before code, agents on the repetition.

My work starts before the first line of code: reading what the client actually needs, fast and in depth, and closing the architecture before anyone opens an editor. The other half is the workflow the team codes inside. I set up AI agents for the repetitive work: pulling their own context, splitting the longer jobs between themselves, reaching real data (RAG) and external tools instead of guessing, and improving at each iteration. Versioned specs and a context harness keep what comes out of them inside the project's conventions.

Recent work spans a Go price-streaming microservice handling real-time market data on Cloud Run and cloud optimization that cut infrastructure costs by 83%. I split roughly 65/35: hands-on coding and architecture review, and leading the team that ships it. Further back, a referral engine that grew a paid base 10×.

Location Rio de Janeiro, Brazil · Remote-first Languages Portuguese (native) · English B2

02 — Skills

Technical stack

Backend

  • Node.js / TypeScript
  • Go
  • Java · Spring Boot
  • C# / .NET
  • Python · Django
  • PHP · Laravel

Frontend

  • React
  • Next.js
  • React Native
  • Vue.js

Cloud & Infra

  • AWS · Lambda
  • ECS / EKS
  • RDS · DynamoDB
  • SQS / SNS
  • GCP · Cloud Run
  • Docker
  • Kubernetes
  • CI/CD

Architecture

  • Microservices
  • Clean Architecture
  • SOLID
  • DDD
  • Event-driven
  • Real-time / SSE
03 — Experience

Where I've shipped

  1. 2025 — 2026Fintech

    Tech Lead · Pipwars

    Rescued an abandoned product, designed the database model, refactored mobile, API and services, and shipped mobile app to the App Store and Google Play. Cut infrastructure costs 83% (BRL 3,000 → BRL 500/mo), most of it by fixing the database behind the bill. Built the Go SSE price-streaming service on Cloud Run. Led a team of three.

    See it live on the App Store ↗ Google Play ↗

    • Go
    • Java
    • React Native
    • GCP
  2. 2025Fintech

    Senior Backend Engineer · Oliveira Trust

    Built and maintained PHP 8+ microservices on AWS (Lambda, SQS, SNS, DynamoDB, ECS/EKS) with Kubernetes. Found and fixed processing bottlenecks with Grafana metrics and JMeter load testing.

    • PHP 8+
    • AWS
    • Kubernetes
  3. 2023 — 2025Healthtech

    Senior Fullstack Engineer · Afya (iClinic)

    Built distributed serverless systems for medical records, prescriptions, and real-time telemedicine. Cut median API response time 16× on the LMS platform and migrated a legacy frontend to Next.js with an in-house design system.

    • Python · Django
    • React / Next.js
    • AWS
  4. 2022 — 2023Anti-fraud

    Fullstack Engineer · Stone Age

    Extended a C# anti-fraud platform that monitors call-center interactions in real time for Brazil's largest banks, flagging impersonation on credit-limit requests.

    • C# / .NET
    • Real-time
  5. 2018 — 2022Edtech

    Fullstack Engineer · Jaleko

    Split a Laravel monolith into two repositories, frontend and API, and built a referral system from scratch that took paid users from 300 to over 3,000.

    • PHP · Laravel
    • Vue.js
    • AWS
04 — Case study

An 83% smaller cloud bill, starting where it hurt most.

PipWars is a gamified trading app: live charts for crypto, forex, gold and silver, with competitions, ranking and subscriptions on top. Infrastructure was running at BRL 3,000 a month and I brought it down to BRL 500. Most of that did not come from the service everyone assumed was the expensive one.

PipWars price-streaming architecture The mobile app opens one SSE connection to the Prices Streaming service, written in Go, which holds two WebSockets to Polygon.io and fans ticks out to every client. The same app talks to the Core API on Spring WebFlux over HTTPS, and the Core API persists to PostgreSQL on Cloud SQL over R2DBC. Mobile app Expo · React Native Prices Streaming Go · Cloud Run stateless fan-out Core API Spring WebFlux Java 17 · reactive Polygon.io market data PostgreSQL Cloud SQL · resized SSE · 1 per chart HTTPS · JWT 2 WebSockets crypto + forex R2DBC

The database was the bill

Cloud SQL was the largest line on the invoice, and the instance was sized for the queries rather than for the data. Routes that ran on every authenticated request were doing sequential scans: the subscription check on every premium endpoint, the open-orders lookup on every portfolio render, a correlated subquery in the ranking that executed once per row returned. I audited them with EXPLAIN ANALYZE against representative staging data, shipped nine composite and partial indexes, and only then dropped the instance tier. Shrinking the machine before fixing the queries would just have moved the timeouts around.

Largest single share of the 83%

Fan out once, not per client

The Prices Streaming service holds one SSE connection per open chart. On the provider side, the whole service holds exactly two WebSockets: one for crypto, one for forex, both subscribed by wildcard. Ticks enter a subscriber map guarded by a mutex and go out to whoever is watching that symbol. That was the gain: ten people watching BTCUSD cost one extra channel each, not one extra provider connection each. It started as five sockets, one per asset; the wildcards collapsed them to two, and it has stayed at two while the catalogue grew to XRP, SOL, gold and silver.

2 upstream connections, any number of users

Python to Go

Rewriting the streaming service in Go came after the database work, and it took a smaller bite out of the bill. What it does is hold thousands of idle connections and move small messages, which is what goroutines exist for: each provider socket and each client stream runs on its own goroutine, talking over channels instead of a thread pool. The deploy image went from 500MB+ to about 5MB, resident memory from 100MB+ to about 10MB, and cold start from over five seconds to under one.

~1,500 lines of Go, 2 dependencies

SSE downstream, WebSocket upstream

Price data only travels one way, so the client leg does not need a duplex protocol. SSE is plain HTTP: no upgrade handshake, no sticky sessions to configure on Cloud Run, and reconnection already lives in the client. The upstream leg has to authenticate and subscribe to topics, so that one stays a WebSocket, reconnecting on exponential backoff from one second to thirty. The app also drops its stream when it goes to background, because concurrent connections are what you pay for.

Stateless

The Core API is where the rest of the product lives: Spring Boot on WebFlux and R2DBC, reactive end to end, Java 17, 254 Flyway migrations, JWT, a Caffeine cache in front of the reads that repeat, and Apple and Google Play subscription webhooks. I wrote roughly two thirds of its commits over sixteen months. Its most recent architecture decision removes hexagonal layering that cost boilerplate and bought nothing: thirty use-case interfaces with a single implementation each, collapsed into feature packages.

See it live on the App Store ↗ Google Play ↗

05 — Contact

Let's build something that scales.

Open to remote and hybrid roles, international or Brazil-based. Book a call or reach me by email.