Currently open to work

Senior Backend Engineer building resilient backends.

I design and ship distributed systems, APIs and event-driven platforms with PHP, Symfony and Node.js — grounded in DDD, Hexagonal Architecture and the SOLID principles. 9+ years shipping production software with international teams.

Currently engineering event-driven platforms that move millions of daily transactions with predictable latency, clean domain boundaries and zero-downtime deploys.

Start a conversation Download resume

Experience: 9+ yrs
Current: HITSS Brasil (Brasília)
Based in: Manaus, BR

namespace App\Leads\Application;

final class LeadProcessor
{
    public function __construct(
        private readonly LeadRepository   $leads,
        private readonly EventPublisher   $bus,
        private readonly ScoringService   $scoring,
    ) {}

    public function __invoke(IngestLead $cmd): void
    {
        $lead  = Lead::fromCommand($cmd);
        $score = $this->scoring->evaluate($lead);

        $this->leads->save($lead->withScore($score));
        $this->bus->publish(new LeadIngested($lead->id()));
    }
}

namespace App\Http\Controllers;

use App\Models\Lead;
use App\Services\ScoringService;
use App\Events\LeadIngested;
use Illuminate\Http\Request;

class LeadController extends Controller
{
    public function __construct(
        private readonly ScoringService $scoring,
    ) {}

    public function ingest(Request $request)
    {
        $lead  = Lead::create($request->validated());
        $score = $this->scoring->evaluate($lead);

        $lead->update(['score' => $score]);
        event(new LeadIngested($lead->id));

        return response()->json(['id' => $lead->id, 'score' => $score]);
    }
}

namespace app\controllers;

use Yii;
use app\models\Lead;
use app\services\ScoringService;
use yii\web\Controller;
use yii\web\Response;

class LeadController extends Controller
{
    public function actionIngest()
    {
        Yii::$app->response->format = Response::FORMAT_JSON;

        $lead = new Lead();
        $lead->load(Yii::$app->request->post(), '');
        $lead->save();

        $scoring = new ScoringService();
        $score   = $scoring->evaluate($lead);

        $lead->score = $score;
        $lead->save();

        return ['id' => $lead->id, 'score' => $score];
    }
}

import { Body, Controller, Post, UseGuards } from '@nestjs/common';
import { ApiTags } from '@nestjs/swagger';
import { JwtGuard } from './auth/jwt.guard';
import { LeadsService } from './leads.service';
import { IngestLeadDto } from './dto/ingest-lead.dto';

@ApiTags('leads')
@UseGuards(JwtGuard)
@Controller('leads')
export class LeadsController {
  constructor(private readonly leads: LeadsService) {}

  @Post()
  async ingest(@Body() dto: IngestLeadDto) {
    const lead = await this.leads.ingest(dto);
    return { id: lead.id, score: lead.score };
  }
}

import { Router } from 'express';
import { LeadsService } from './leads.service';

const router = Router();
const leads  = new LeadsService();

router.post('/leads', async (req, res) => {
  const lead = await leads.ingest(req.body);
  res.json({ id: lead.id, score: lead.score });
});

export default router;

import type { FastifyInstance } from 'fastify';
import { LeadsService } from './leads.service';

export async function leadsRoutes(app: FastifyInstance) {
  const leads = new LeadsService();

  app.post('/leads', async (request, reply) => {
    const lead = await leads.ingest(request.body as IngestLead);
    return reply.send({ id: lead.id, score: lead.score });
  });
}

import { useQuery } from '@tanstack/react-query';
import { LeadsTable, EmptyState, Spinner } from '@/components';
import { fetchLeads } from '@/api/leads';

export default function LeadsPage() {
  const { data, isLoading, error } = useQuery({
    queryKey: ['leads'],
    queryFn:  fetchLeads,
    staleTime: 30_000,
  });

  if (isLoading) return <Spinner />;
  if (error)     return <EmptyState title="Failed to load" />;

  return (
    <section className="p-6">
      <h1 className="text-2xl font-bold">Leads</h1>
      <p className="mt-1 text-slate-400">{data.length} total</p>
      <LeadsTable rows={data} />
    </section>
  );
}

import { LeadsTable } from '@/components';
import { getLeads } from '@/lib/leads';

export const revalidate = 60;

export default async function LeadsPage() {
  const leads = await getLeads();

  return (
    <section className="p-6">
      <h1 className="text-2xl font-bold">Leads</h1>
      <p className="mt-1 text-slate-400">{leads.length} total</p>
      <LeadsTable rows={leads} />
    </section>
  );
}

LeadsPage.vue

<script setup lang="ts">
import { ref, onMounted } from 'vue';
import { fetchLeads } from '@/api/leads';
import LeadsTable from '@/components/LeadsTable.vue';

const leads   = ref([]);
const loading = ref(true);

onMounted(async () => {
  leads.value   = await fetchLeads();
  loading.value = false;
});
</script>

<template>
  <section class="p-6">
    <h1 class="text-2xl font-bold">Leads</h1>
    <p class="mt-1 text-slate-400">{{ leads.length }} total</p>
    <LeadsTable :rows="leads" v-if="!loading" />
  </section>
</template>

leads-page.component.ts

import { Component, inject, signal, OnInit } from '@angular/core';
import { LeadsTableComponent } from './leads-table.component';
import { LeadsService } from './leads.service';

@Component({
  selector: 'app-leads-page',
  standalone: true,
  imports: [LeadsTableComponent],
  templateUrl: './leads-page.component.html',
})
export class LeadsPageComponent implements OnInit {
  private leadsService = inject(LeadsService);

  leads   = signal<Lead[]>([]);
  loading = signal(true);

  async ngOnInit() {
    this.leads.set(await this.leadsService.fetchAll());
    this.loading.set(false);
  }
}

package app.leads;

import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;

@RestController
@RequestMapping("/leads")
public class LeadController {

  private final LeadService leads;

  public LeadController(LeadService leads) {
    this.leads = leads;
  }

  @PostMapping
  public ResponseEntity<LeadView> ingest(@RequestBody IngestLead cmd) {
    LeadView view = leads.ingest(cmd);
    return ResponseEntity.ok(view);
  }
}

package app.leads;

import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import io.smallrye.mutiny.Uni;

@Path("/leads")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class LeadResource {

  @Inject LeadService leads;

  @POST
  public Uni<LeadView> ingest(IngestLead cmd) {
    return leads.ingest(cmd)
        .map(LeadView::from);
  }
}

package app.leads;

import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import jakarta.inject.Inject;
import jakarta.enterprise.context.RequestScoped;

@Path("/leads")
@RequestScoped
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class LeadResource {

  @Inject LeadService leads;

  @POST
  public LeadView ingest(IngestLead cmd) {
    return LeadView.from(leads.ingest(cmd));
  }
}

package leads

func HandleIngest(scoring ScoringService, repo Repository, bus EventPublisher) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        var cmd IngestLead
        if err := json.NewDecoder(r.Body).Decode(&cmd); err != nil {
            http.Error(w, err.Error(), http.StatusBadRequest)
            return
        }

        lead := NewLeadFromCommand(cmd)
        score, err := scoring.Evaluate(r.Context(), lead)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }

        lead = lead.WithScore(score)
        repo.Save(r.Context(), lead)
        bus.Publish(r.Context(), LeadIngested{ID: lead.ID})

        json.NewEncoder(w).Encode(lead)
    }
}

package leads

func RegisterRoutes(r *gin.Engine, scoring ScoringService, repo Repository, bus EventPublisher) {
    r.POST("/leads", func(c *gin.Context) {
        var cmd IngestLead
        if err := c.ShouldBindJSON(&cmd); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }

        lead := NewLeadFromCommand(cmd)
        score, err := scoring.Evaluate(c, lead)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }

        lead = lead.WithScore(score)
        repo.Save(c, lead)
        bus.Publish(c, LeadIngested{ID: lead.ID})

        c.JSON(http.StatusOK, lead)
    })
}

package leads

func RegisterRoutes(app *fiber.App, scoring ScoringService, repo Repository, bus EventPublisher) {
    app.Post("/leads", func(c *fiber.Ctx) error {
        var cmd IngestLead
        if err := c.BodyParser(&cmd); err != nil {
            return fiber.NewError(fiber.StatusBadRequest, err.Error())
        }

        lead := NewLeadFromCommand(cmd)
        score, err := scoring.Evaluate(c.Context(), lead)
        if err != nil {
            return err
        }

        lead = lead.WithScore(score)
        repo.Save(c.Context(), lead)
        bus.Publish(c.Context(), LeadIngested{ID: lead.ID})

        return c.JSON(lead)
    })
}

SELECT
  DATE_FORMAT(l.created_at, '%Y-%m-01') AS cohort,
  COUNT(DISTINCT l.id)                  AS customers,
  SUM(s.amount)                         AS mrr,
  ROUND(AVG(s.amount), 2)               AS arpu
FROM leads l
JOIN subscriptions s ON s.lead_id = l.id
WHERE l.status = 'converted' AND s.active = 1
GROUP BY cohort
HAVING COUNT(DISTINCT l.id) > 50
ORDER BY cohort DESC
LIMIT 24;

WITH cohorts AS (
  SELECT id,
         date_trunc('month', created_at) AS cohort
  FROM   leads
  WHERE  status = 'converted'
)
SELECT c.cohort,
       COUNT(DISTINCT c.id)                      AS customers,
       SUM(s.amount)                                 AS mrr,
       ROUND(AVG(s.amount)::numeric, 2)          AS arpu,
       RANK() OVER (ORDER BY SUM(s.amount) DESC) AS rnk
FROM      cohorts       c
JOIN      subscriptions s ON s.lead_id = c.id
WHERE     s.active
GROUP BY  c.cohort
HAVING    COUNT(DISTINCT c.id) > 50
ORDER BY  c.cohort DESC
LIMIT     24;

SELECT cohort, customers, mrr, arpu FROM (
  SELECT
    TRUNC(l.created_at, 'MM')      AS cohort,
    COUNT(DISTINCT l.id)           AS customers,
    SUM(s.amount)                  AS mrr,
    ROUND(AVG(s.amount), 2)        AS arpu
  FROM leads l
  JOIN subscriptions s ON s.lead_id = l.id
  WHERE l.status = 'converted' AND s.active = 1
  GROUP BY TRUNC(l.created_at, 'MM')
  HAVING COUNT(DISTINCT l.id) > 50
)
ORDER BY cohort DESC
FETCH FIRST 24 ROWS ONLY;

db.leads.aggregate([
  { $match: { status: 'converted' } },
  {
    $lookup: {
      from: 'subscriptions',
      localField: '_id',
      foreignField: 'leadId',
      as: 'subs',
    },
  },
  { $unwind: '$subs' },
  { $match: { 'subs.active': true } },
  {
    $group: {
      _id: { $dateTrunc: { date: '$createdAt', unit: 'month' } },
      customers: { $addToSet: '$_id' },
      mrr: { $sum: '$subs.amount' },
      arpu: { $avg: '$subs.amount' },
    },
  },
  { $match: { $expr: { $gt: [{ $size: '$customers' }, 50] } } },
  { $sort: { _id: -1 } },
  { $limit: 24 },
]);

Dockerfile

FROM composer:2 AS deps
WORKDIR /app
COPY composer.*  ./
RUN  composer install --no-dev --no-scripts --prefer-dist

FROM php:8.3-fpm-alpine AS runtime
WORKDIR /app

RUN  apk add --no-cache icu-dev postgresql-dev \
  && docker-php-ext-install opcache intl pdo_pgsql

COPY --from=deps /app/vendor ./vendor
COPY . .

ENV APP_ENV=prod PHP_OPCACHE_VALIDATE_TIMESTAMPS=0
USER www-data

HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -fsS http://localhost:9000/health || exit 1

EXPOSE 9000
CMD ["php-fpm", "-F"]

leads-api.deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: leads-api
  labels: { app: leads-api, tier: backend }
spec:
  replicas: 3
  selector: { matchLabels: { app: leads-api } }
  strategy: { type: RollingUpdate, rollingUpdate: { maxSurge: 1, maxUnavailable: 0 } }
  template:
    metadata: { labels: { app: leads-api } }
    spec:
      containers:
        - name: api
          image: ghcr.io/dg/leads-api:1.8.0
          ports: [{ containerPort: 9000 }]
          envFrom: [{ secretRef: { name: leads-secrets } }]
          resources:
            requests: { cpu: "100m", memory: "256Mi" }
            limits:   { cpu: "500m", memory: "512Mi" }
          readinessProbe: { httpGet: { path: /health, port: 9000 }, periodSeconds: 5 }
          livenessProbe:  { httpGet: { path: /alive,  port: 9000 }, periodSeconds: 15 }

.gitlab-ci.yml

stages: [test, build, deploy]

variables:
  IMAGE: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA

test:
  stage: test
  image: node:20-alpine
  script:
    - npm ci --prefer-offline
    - npm run lint && npm test -- --coverage

build:
  stage: build
  image: docker:25
  services: [docker:dind]
  script:
    - docker build -t $IMAGE .
    - docker push $IMAGE

deploy:eks:
  stage: deploy
  image: bitnami/kubectl:latest
  environment: production
  only: [main]
  script:
    - aws eks update-kubeconfig --name leads-prod --region us-east-1
    - kubectl set image deploy/leads-api api=$IMAGE
    - kubectl rollout status deploy/leads-api --timeout=5m

DDD · Hexagonal · CQRS-lite php 8.3 · symfony

01 — About

A backend engineer who cares about clarity.

I'm Dário, a Senior Backend Engineer from the Amazon, currently building Node.js/TypeScript/NestJS microservices at HITSS Brasil in Brasília — my second stint with the company. Previously, I contributed to a Stripe payments integration (SDK, webhooks, wallets) at Leadtech (via Ciklum) in Barcelona. Over the past 9+ years I've worked alongside cross-functional teams across PHP, Node.js, Java and Go, modernized legacy monoliths and shipped event-driven, government-scale systems for companies in Brazil, Spain and Latin America.

My focus is building software that survives real traffic and real teams — clean boundaries, explicit domain models, message-driven integration and observability baked in. Whether shipping payments at fintech scale or government-grade public services, I believe simple code wins, tests are a design tool, and the best systems are boring by intent.

Designing systems with DDD & Hexagonal Architecture
Async pipelines with RabbitMQ & Kafka
PostgreSQL modeling, query & transaction design
CI/CD with Jenkins + Docker on AWS & GCP
Leading & mentoring cross-functional teams
Fluent in PT (native) · EN (C1) · ES (C1)

02 — Stack

Tools I reach for every day.

A pragmatic toolkit built around backend engineering, distributed systems and delivery.

Backend

PHP 8
Symfony
Laravel
Yii
Node.js
NestJS
TypeScript
Java
Spring
Quarkus
Go
Doctrine
REST
GraphQL

Architecture

DDD
Hexagonal
Clean Arch
SOLID
CQRS-lite
Event-driven
Microservices

Messaging & Data

RabbitMQ
Kafka
PostgreSQL
Oracle
MySQL
Redis
Elasticsearch
MinIO

Cloud & DevOps

AWS · EKS · RDS · ECR
GCP
Kubernetes
Docker
Jenkins
GitLab CI
GitHub Actions
Linux

Frontend

TypeScript
Vue.js
React
Next.js
Angular
Tailwind CSS
HTML5

Recent focus

Java & Spring (gov-tech)
AWS EKS · Cloud-native
Event sourcing
NestJS at scale

03 — Experience

9+ years shipping production software.

Current May 2026 — Present

Senior Backend Engineer · HITSS Brasil

Brasília, Brazil · Remote

Building Node.js/TypeScript/NestJS microservices — my second engagement with HITSS after the government-platforms project in Rio de Janeiro, this time focused on distributed service design and API delivery from Brasília.
Sep 2025 — Jun 2026
Senior Backend Engineer · Leadtech (via Ciklum)

Barcelona, Spain · Remote

Contributed to APIs for payments, subscriptions, e-signatures and AI-driven document workflows on PHP 8 + Symfony + Doctrine + GraphQL/REST + PostgreSQL + RabbitMQ, including a Stripe integration (SDK, webhooks, wallets). Architecture grounded in DDD, Hexagonal and SOLID — explicit aggregates, idempotent transactions and clean bounded contexts that scale with new markets.
Oct 2023 — Oct 2025
Senior Backend Engineer · Global HITSS Brasil

Rio de Janeiro, Brazil

Multi-stack senior on Brazilian government platforms across multiple ministries (Agriculture, Fisheries). Delivered services in PHP/Symfony, Node.js/NestJS/TypeScript and Java/Spring Boot/Quarkus/JPA, with Next.js + React frontends. Engineered a complex federal payment system integration estimated at 4 months and delivered in significantly reduced timeframe. Operated PostgreSQL, Oracle, Redis (caching) and Elasticsearch (log analysis) on AWS and GCP, with RabbitMQ + Kafka messaging and Jenkins + Docker CI/CD.
Oct 2020 — Sep 2023
Senior Backend Engineer · Westwing Brasil

São Paulo, Brazil

Backend on a high-traffic e-commerce platform — millions of monthly sessions. Shipped checkout, order and inventory features across Symfony, Laravel and Node.js, with Vue.js frontends, and used Go for performance-critical microservices. Built financial systems for supplier payments, settlements and dividend processing, integrated with Adyen, PIX and Salesforce. Optimized production via Redis caching strategies and Elasticsearch log analysis across production and staging environments.
Jun 2017 — Sep 2020
Senior Backend Engineer · Vekttor · iComanda

Manaus, Brazil

Led the team in modernizing legacy PHP systems. Built internal tools in Node.js, Vue.js and React, and shipped features like SAT fiscal invoice issuance, a WhatsApp messaging API and a distributed P2P server for offline-capable POS. Owned CI/CD pipelines and drove scalability and performance initiatives.

04 — Projects

Selected work.

Representative initiatives — distilled from real-world delivery across my career.

Federal Treasury Payment Integration

Java · Spring Boot · PostgreSQL · Oracle

Payments

Complex federal payment system integration estimated at 4 months and delivered in a significantly reduced timeframe. Required precise transactional integrity, idempotent processing and full audit trails to meet public-sector compliance under high concurrency.

Java
Spring
Idempotency
Audit
Gov-scale

Cloud-Native SaaS Platform

NestJS · TypeORM · React · AWS EKS

Platform

Side-project SaaS platform built end-to-end with NestJS + TypeORM on PostgreSQL, Redis caching and MinIO storage on the backend, React frontend, deployed to AWS EKS / RDS / ECR with GitLab CI pipelines and infrastructure as code.

NestJS
TypeORM
EKS
GitLab CI
MinIO

Fiscal Invoicing Gateway (SAT)

PHP · Node.js · PostgreSQL

Payments

Real-time fiscal invoice issuance integrated with the Brazilian SAT protocol, handling thousands of daily transactions for restaurant chains. Built for reliability under flaky network conditions with idempotent retries and audit trails.

SAT
Idempotency
Retries
Audit

Agricultural Marketplace Platform

NestJS · Next.js · PostgreSQL · Redis

Marketplace

Multi-tenant marketplace platform for the Brazilian Ministry of Agriculture. NestJS backend services, Next.js storefront and Redis caching for fast catalog browsing — designed to onboard suppliers and surface public procurement at national scale.

Multi-tenant
NestJS
Next.js
Redis

WhatsApp Messaging API

Node.js · Redis · Queues

Integrations

Unified messaging layer bridging WhatsApp Business API and internal CRM workflows. Throttled outbound pipelines, webhook fan-out and delivery guarantees with queue-based backpressure, logging and observability built in from day one.

Webhooks
Backpressure
Observability

Distributed P2P Sync Server

PHP · Sockets · SQLite

Distributed

Self-healing synchronization server for POS terminals in offline-capable environments. Conflict-resilient state merging, heartbeat-based peer discovery and automatic reconciliation when connectivity returns — built for the real world.

P2P
Offline-first
Reconciliation

05 — Contact

Have a project in mind? Let's build it together.

Open to senior backend and staff-level roles — remote-first, international teams. The best way to reach me is by email.

dariogabriel2334@gmail.com

GitHub: dgabriel2334
WhatsApp: +55 11 91092-1684
FaceTime: +55 92 98117-4082
Location: Manaus — Brazil
Languages: PT · EN (C1) · ES (C1)