Guilherme Alves
pten
Contato
Guilherme Alves · Desenvolvedor Back-End

Sistemas em tempo real,do CLP ao navegador

Back-end em Go, TypeScript/Bun e Python. Construo serviços que conversam com equipamento industrial, aprendem com os dados e continuam testáveis sem o hardware ligado.

Ver projetosContato
  • Go
  • Gin
  • TypeScript
  • Bun
  • Python
  • scikit-learn
  • PostgreSQL
  • SQLite
  • Prisma
  • Docker
  • GitHub Actions
  • WebSocket
  • Modbus TCP
  • Raspberry Pi
  • nginx
  • React

Execução

Conectado

Ver todos os links

Perfil

Guilherme AlvesDesenvolvedor Back-End
Cargo
Desenvolvedor
Exp
1 ano
Base
Rio Verde · GO
Stack
Go · TS/Bun · Python
Modo
Back-End

Stack

GoTSBunPy
Destaques

Números quesaíram do código

Resultados medidos em produção, no back-end que eu escrevo e mantenho.

01 ■ Desempenho

−0%

Payload do painel no 1º acesso

4,75 MB → 1,26 MB

AntesDepois
02 ■ Consultas

96,00ms

Paginação de eventos com índice

antes 96 ms · 300 mil registros

AntesDepois
03 ■ Rede

40→40

Chamadas à API sobre conexões TCP

trocar de tela não reconecta o WebSocket

AntesDepois
04 ■ Impacto

R$0mil/mês

Redução de custo na Cargill, Jataí-GO

algoritmos determinístico + random forest do pid-service

Em produção

Contribuições · últimos 12 meses

0contribuições

github.com/guialvesrf
Fonte: GitHub · atualiza 1× por dia
Experiência

Onde eu colococódigo em produção

Back-end que roda dentro da planta do cliente e, antes disso, um ano mentorando uma comunidade de programação.

  1. jun. de 2026 – o momento

    atual
    • 6 meses
    • Rio Verde, Goiás, Brasil
    • Presencial

    Desenvolvedor Back-End (Inovação/P&D)

    Comber Indústria LTDATempo integral

    Back-end de dois produtos: uma plataforma em tempo real que roda embarcada em Raspberry Pi 5 e PCs industriais dentro da planta do cliente, e a aplicação web do administrativo para a comissão dos representantes. Os produtos são confidenciais. Aqui fica o lado de engenharia.

    • Fan-out em tempo real: um serviço lê o CLP via Modbus TCP e publica os dados por WebSocket para dois consumidores, o serviço de ajuste adaptativo e o supervisório web.
    • Supervisório em Go (Gin) e SQLite, com front em React atrás do nginx. Operador e supervisor acompanham a operação ao vivo e exportam XLSX e CSV. Auth com JWT, refresh token rotacionado, três níveis de permissão e rate limit no login.
    • Patch de performance do supervisório (v1.16): o painel principal caiu de 4,75 MB para 1,26 MB no primeiro acesso (−74%). A paginação de eventos foi de 96 ms para 0,04 ms com um índice, em teste com 300 mil registros. 40 chamadas à API passaram a usar 10 conexões TCP, e trocar de tela não reconecta mais nenhum WebSocket.
    • Serviço de ajuste adaptativo de parâmetros de controle: começa com um algoritmo determinístico e, depois de juntar dados suficientes, passa a usar random forest. Fica em portas e adaptadores, então eu testo tudo sem o equipamento ligado.
    • Release no GitHub Actions com imagens Docker para arm64 e amd64. Quando uma versão passou nos testes e não subiu na Pi 5 por causa das páginas de memória de 16 KB, achei a causa por SSH e publiquei a correção no mesmo dia.
    • Aplicação de comissões em TypeScript, Express, Prisma e PostgreSQL. PRD de 51 requisitos antes de codar, 524 testes automatizados, integração num Postgres isolado e CI.
    • Go
    • Gin
    • SQLite
    • React
    • nginx
    • Python
    • Modbus TCP
    • WebSocket
    • scikit-learn
    • Docker
    • GitHub Actions
    • TypeScript
    • Express
    • Prisma
    • PostgreSQL

  2. jul. de 2025 – jun. de 2026

    encerrado
    • 1 ano
    • Remoto

    Mentor de Programação & Gerente de Comunidade

    BeroLabMeio período

    Mentoria técnica e de carreira numa comunidade de programação.

    • Ofereci suporte contínuo em hard skills (tecnologia) e soft skills (comunicação e carreira), auxiliando no desenvolvimento dos membros da comunidade.
    • Criei e conduzi mentorias de carreira e de apresentação profissional para membros da comunidade.
    • Conduzi a iniciativa “Em busca do SaaS Automático”: encontros semanais que guiaram a comunidade na concepção e implementação de produtos SaaS com modelo de receita recorrente.
    • Auxiliei na resolução de dúvidas técnicas e problemas práticos, promovendo autonomia e aprendizado constante.
    • Participei de workshops e eventos, fortalecendo o engajamento e a troca de conhecimento entre membros.
    • Mentoria
    • Carreira
    • SaaS
    • Comunicação
    • Comunidade
Projetos

Do chão de fábricaao financeiro

Os dois sistemas que construo na Comber: um roda ao lado do equipamento, na planta do cliente; o outro fecha as comissões do comercial. São produtos confidenciais, então aqui entram só arquitetura e engenharia.

01 ■ ISAem produção

ISA

2026 — atualBack-end · Comber

Supervisão e controle adaptativo para equipamento industrial. Lê o CLP via Modbus, ajusta o PID episódio a episódio e entrega um supervisório web na rede da planta, tudo em contêineres que rodam de um Raspberry Pi 5 a um PC industrial.

  • Um único dono da conexão Modbus: o CLP aceita um cliente por vez, então o core-isa faz uma varredura por segundo e todos os serviços consomem a mesma leitura. Agrupar faixas contíguas reduziu 64 leituras a 27 requisições por ciclo.
  • Cada valor carrega sua qualidade (good, bad, stale, unmapped). Falha de leitura devolve o último valor bom marcado como ruim, nunca um 0.0 que se passe por medição.
  • Back-end do supervisório em Go/Gin com SQLite sem CGO: binário estático em imagem distroless e cross-compile direto para arm64. Sessão por JWT de 15 min com refresh rotativo em cookie HttpOnly.
  • Entrega em frota: cada tag roda os testes e só então publica imagens amd64 + arm64 no GHCR. Provisionamento por script, canais beta e stable, rollback e bundle offline para plantas sem internet.
serviços em contêiner
0
arquiteturas: amd64 e arm64
0
testes automatizados
0+
porta exposta na planta
0
  • Go
  • Gin
  • SQLite
  • Python
  • FastAPI
  • Modbus TCP
  • React
  • Docker
  • GitHub Actions

Arquitetura da ISA: o CLP do equipamento conversa por Modbus TCP só com o core-isa, que repassa as leituras por HTTP ao pid-service e por WebSocket ao web-backend em Go. O web-backend grava em SQLite e é publicado pelo nginx do web-frontend, a única porta aberta para o navegador do operador. Tudo roda em Docker Compose num Raspberry Pi 5 ou num PC industrial.

02 ■ Comissõesem produção

Comissões

2026 — atualBack-end · Comber

Sistema interno que lança vendas e recebimentos e calcula as comissões do comercial, com cadastros, dashboard e relatórios em PDF e Excel. Uma API em TypeScript sobre PostgreSQL que também serve o front-end.

  • PRD com 51 requisitos escrito antes da primeira linha de código. Features novas seguem spec com critérios rastreáveis e verificação independente, inclusive com testes de mutação.
  • API Express 5 em camadas (rota, controller, service, repository), entrada validada com Zod e identidade sempre extraída do token, nunca do corpo da requisição.
  • A API serve o build do React na mesma origem: uma porta, nenhum IP fixo em arquivo e o mesmo build no PC e no servidor. Cookie HttpOnly, CSP com Helmet e rate limit no login.
  • 524 testes com Vitest e Supertest. As 43 suítes de rota rodam num Postgres de teste isolado, e a config se recusa a rodar sem ele, porque os testes limpam as tabelas. O CI repete tudo a cada PR, com lint, typecheck e migrations.
requisitos no PRD
0
testes automatizados
0
suítes de integração
0
porta para API e front
0
  • TypeScript
  • Node 24
  • Express
  • Prisma
  • PostgreSQL
  • Zod
  • React
  • Vite
  • Vitest
  • Docker

Arquitetura do Comissões: o navegador chama /api na mesma origem; a API Express serve o build do React e acessa o PostgreSQL pelo Prisma, tudo em um contêiner e uma porta. No CI, o GitHub Actions roda lint, typecheck, migrations e testes contra um Postgres de teste isolado.

Engenharia

Por dentro do queeu construí

Os sistemas por trás dos números, animados a partir do código real. Nomes de planta e valores de calibração ficam de fora.

01 ■ Tempo reallive

Fan-out do CLP via WebSocket

Um único dono da conexão Modbus lê o CLP uma vez por segundo e distribui a mesma leitura para o supervisório e para o serviço de ajuste adaptativo.

  • Modbus TCP
  • WebSocket
  • Go · Gin
  • Python
  • 1 socket · N clientes

Diagrama animado: o CLP aceita uma única conexão Modbus TCP. O core-isa é o único dono dessa conexão, lê o CLP uma vez por segundo e publica a mesma leitura por WebSocket para dois consumidores: o web-service, supervisório em Go com Gin e SQLite, e o pid-service, que faz o ajuste adaptativo em Python. Mais navegadores abertos não geram tráfego extra no CLP.

02 ■ pid-service · determinísticolive

Sintonia por regras e trilhos

Cada episódio mede overshoot, oscilação, offset e saturação. A primeira regra que casa ajusta P, I e D, sempre dentro de ±30% e dos limites.

  • Python
  • NumPy
  • Portas e adaptadores
  • Episódios de 5 min

Animação de três episódios de sintonia. Cada episódio tem 300 amostras de temperatura (cerca de 5 minutos), filtradas por mediana de 3. A partir do primeiro cruzamento do setpoint, a janela de regulação, saem overshoot, undershoot, oscilação e offset (desvio padrão e média do último quarto) e a fração de Hz saturado, que compõem um score ponderado: menor é melhor. As regras são avaliadas nesta ordem e a primeira que casa decide: 1, overshoot ou undershoot, aumenta D e reduz P; 2, Hz saturado ou varrendo a faixa, reduz P e aumenta D; 3, oscilação, reduz P e I; 4, offset abaixo do setpoint, aumenta I e P levemente; 5, offset acima, reduz P e I; senão mantém o PID. O PID sugerido passa pelos trilhos: no máximo ±30% por episódio e dentro dos limites. No exemplo, o episódio 1 tem overshoot e o D sugerido bate no limite; o episódio 2 oscila; o episódio 3 fica dentro da tolerância e o PID é mantido.

03 ■ pid-service · machine learninglive

Random Forest sobre o histórico

Depois de 20 episódios de regime, uma floresta de 80 árvores prevê o score de 125 combinações de P, I e D ao redor do atual e escolhe a menor.

  • scikit-learn
  • RandomForestRegressor
  • argmin
  • off · shadow · drive

Animação da camada de machine learning do pid-service. Enquanto o histórico tem menos de 20 episódios de regime, as regras determinísticas decidem. Com 20, um RandomForestRegressor de 80 árvores é treinado com P, I, D, nível e setpoint para prever o score do episódio. Ele avalia uma grade de 5 × 5 × 5 = 125 candidatos, cada ganho entre −30% e +30% do PID atual, e escolhe o de menor score previsto (argmin). A sugestão passa pelos mesmos trilhos das regras, ±30% por episódio e limites, e só é aplicada no modo drive; em shadow ela só é registrada e em off a camada fica desligada. Se as predições praticamente empatam (variação menor que 1%), as regras decidem. O loop alterna entre dois perfis de operação.

04 ■ Projeto pessoal · Golive

Guardian, cofre zero-knowledge

A senha mestre nunca sai da máquina. O cliente deriva as chaves e cifra cada item; o servidor só guarda blobs opacos que não consegue ler.

  • Go
  • Argon2id
  • HKDF-SHA256
  • AES-256-GCM
  • TOTP
  • PostgreSQL

Diagrama animado do Guardian, gerenciador de senhas zero-knowledge. A senha mestre passa por Argon2id e vira a master key, que o HKDF-SHA256 divide em auth hash e enc key. Só o auth hash vai ao servidor, que guarda um Argon2id dele. A enc key nunca sai do cliente: ela abre a vault key com AES-256-GCM, e a vault key cifra cada item, inclusive o nome, com AES-256-GCM e AAD ligada ao usuário e ao item. O servidor recebe e guarda apenas blobs opacos no PostgreSQL.

Stack

As linguagensque eu uso todo dia

Três linguagens, cada uma onde rende mais: Go nos serviços, TypeScript nas aplicações web e Python nos dados e na comunicação com o CLP.

Go

go 1.27 · produção

Concorrência simples com goroutines e um binário único, sem runtime para instalar: ótimo para serviços de rede. Uso no supervisório web em Gin + SQLite (REST + WebSocket, JWT com refresh rotacionado e rate limit) e no Guardian, um gerenciador de senhas zero-knowledge com TUI.

  • Gin
  • SQLite
  • WebSocket
  • JWT
  • x/crypto
  • x/term
~/app — zsh
$ go mod init github.com/guialvesrf/app
go: creating new go.mod: module github.com/guialvesrf/app

TypeScript / Bun

ts 6 · api + web

A tipagem pega o erro antes de chegar em produção, e o Bun completa o par como runtime rápido, com bundler e test runner embutidos. Na aplicação de comissões, a API usa Express, Prisma e PostgreSQL, com testes automatizados e CI no GitHub Actions.

  • Express
  • Prisma
  • PostgreSQL
  • React
  • Vite
  • Vitest
~/app — zsh
$ bun init -y
+ .gitignore
+ index.ts
+ tsconfig.json (for editor autocomplete)
+ README.md
To get started, run:
  bun run index.ts

Python

python 3.14 · dados + CLP

Ecossistema científico maduro: álgebra, estatística e machine learning sem reinventar nada. Uso no serviço de ajuste adaptativo (NumPy e random forest do scikit-learn), organizado em portas e adaptadores, e no core que conversa com o CLP via Modbus TCP.

  • NumPy
  • scikit-learn
  • httpx
  • pymodbus
~/app — zsh
$ python3 -m venv .venv && source .venv/bin/activate
Também no dia a dia
  • Docker
  • GitHub Actions
  • PostgreSQL
  • SQLite
  • nginx
  • Raspberry Pi
  • Linux
Conquistas

Vencedor doHackathon FIAP

1º lugar na Global Solution Future at Work 2025, o hackathon da FIAP realizado em 11 de novembro de 2025.

FIAPglobal solutionFutureAtWork

O Centro Universitário FIAP certifica que

Guilherme Alves Rodrigues Ferreira

Ganhou a Global Solution Future at Work 2025, realizado no dia 11 de novembro, com uma carga horária de 2 horas.

1º lugar · Hackathon11.11.2025

Desafio da FIAP com o tema Future at Work: pensar, construir e apresentar, contra o relógio, uma solução de tecnologia para o futuro do trabalho. O projeto ficou com o 1º lugar da edição 2025.

  • Hackathon
  • FIAP
  • Future at Work
  • 2025
Certificado original · FIAP
Certificado da FIAP: Guilherme Alves Rodrigues Ferreira ganhou a Global Solution Future at Work 2025, realizada em 11 de novembro, com carga horária de 2 horas.
Formação

Baseacadêmica

Engenharia de Software, na FIAP e agora na UniRV.

  • 2026 – atual

    Bacharelado em Engenharia de Software

    UniRV · Universidade de Rio Verde

    cursando

  • 2024 – 2025

    Bacharelado em Engenharia de Software

    FIAP

    encerrado

Vamos construiralgo em tempo real?

Aberto a oportunidades como desenvolvedor back-end.

E-mail
guialves.garf50@hotmail.com
Enviar e-mailLinkedIn(abre em nova aba)GitHub(abre em nova aba)Instagram(abre em nova aba)

@guialvesrf em todas as redes