Guilherme Alves
pten
Contact
Guilherme Alves · Back-End Developer

Real-time systems,from PLC to browser

Back-end in Go, TypeScript/Bun and Python. I build services that talk to industrial equipment, learn from the data and stay testable with the hardware switched off.

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

Execution

Connected

View all links

Profile config

Guilherme AlvesBack-End Developer
Role
Developer
Exp
1 year
Base
Rio Verde · GO
Stack
Go · TS/Bun · Python
Mode
Back-End

Stack

GoTSBunPy
Highlights

Numbers thatcame out of the code

Results measured in production, on the back end I write and maintain.

01 ■ Performance

−0%

Dashboard payload on first load

4.75 MB → 1.26 MB

BeforeAfter
02 ■ Queries

96.00ms

Event pagination with an index

was 96 ms · 300k rows

BeforeAfter
03 ■ Network

40→40

API calls over TCP connections

switching screens no longer reconnects the WebSocket

BeforeAfter
04 ■ Impact

R$0k/mo

Cost reduction at Cargill, Jataí-GO, Brazil

deterministic + random forest algorithms in pid-service

In production

Contributions · last 12 months

0contributions

github.com/guialvesrf
Source: GitHub · refreshed daily
Experience

Where I shipcode to production

Back end that runs inside the client’s plant and, before that, a year mentoring a programming community.

  1. Jun 2026 – Present

    current
    • 6 mos
    • Rio Verde, Goiás, Brazil
    • On-site

    Back-End Developer (Innovation/R&D)

    Comber Indústria LTDAFull-time

    Back end for two products: a real-time platform that runs embedded on Raspberry Pi 5 boards and industrial PCs inside the client’s plant, and the back-office web app that handles sales rep commissions. The products are confidential, so this is the engineering side.

    • Real-time fan-out: one service reads the PLC over Modbus TCP and publishes the data over WebSocket to two consumers, the adaptive tuning service and the web supervisory dashboard.
    • Supervisory dashboard in Go (Gin) and SQLite, with a React front end behind nginx. Operators and supervisors follow the operation live and export XLSX and CSV. Auth with JWT, rotating refresh tokens, three permission levels and login rate limiting.
    • Dashboard performance patch (v1.16): the main panel dropped from 4.75 MB to 1.26 MB on first load (−74%). Event pagination went from 96 ms to 0.04 ms with a single index, tested against 300k records. 40 API calls now share 10 TCP connections, and switching screens no longer reconnects any WebSocket.
    • Adaptive control-parameter tuning service: it starts with a deterministic algorithm and, once it has gathered enough data, switches to a random forest. Built on ports and adapters, so I test everything without the equipment powered on.
    • Releases on GitHub Actions with Docker images for arm64 and amd64. When a version passed the tests but wouldn’t start on the Pi 5 because of its 16 KB memory pages, I tracked down the cause over SSH and shipped the fix the same day.
    • Commissions app in TypeScript, Express, Prisma and PostgreSQL. A 51-requirement PRD before writing code, 524 automated tests, integration tests against an isolated Postgres, and CI.
    • Go
    • Gin
    • SQLite
    • React
    • nginx
    • Python
    • Modbus TCP
    • WebSocket
    • scikit-learn
    • Docker
    • GitHub Actions
    • TypeScript
    • Express
    • Prisma
    • PostgreSQL

  2. Jul 2025 – Jun 2026

    ended
    • 1 yr
    • Remote

    Programming Mentor & Community Manager

    BeroLabPart-time

    Technical and career mentoring in a programming community.

    • Gave ongoing support in hard skills (technology) and soft skills (communication and career), helping community members grow.
    • Created and ran career and professional-presentation mentoring sessions for community members.
    • Led the “Em busca do SaaS Automático” initiative (“In search of the automatic SaaS”): weekly sessions that guided the community through designing and building SaaS products with recurring revenue.
    • Helped work through technical questions and hands-on problems, encouraging autonomy and continuous learning.
    • Took part in workshops and events, strengthening engagement and knowledge sharing among members.
    • Mentoring
    • Career
    • SaaS
    • Communication
    • Community
Projects

From the plant floorto finance

The two systems I build at Comber: one runs next to the equipment at the customer's plant, the other settles sales commissions. Both are confidential, so this is architecture and engineering only.

01 ■ ISAin production

ISA

2026 — presentBack-end · Comber

Supervision and adaptive control for industrial equipment. It reads the PLC over Modbus, tunes the PID episode by episode and serves a web HMI on the plant network, all in containers that run on anything from a Raspberry Pi 5 to an industrial PC.

  • One owner for the Modbus connection: the PLC accepts a single client at a time, so core-isa scans once per second and every service reads the same snapshot. Merging contiguous ranges cut 64 reads down to 27 requests per cycle.
  • Every value carries its quality (good, bad, stale, unmapped). A failed read returns the last good value flagged as bad, never a 0.0 that passes for a measurement.
  • Supervisory back-end in Go/Gin with CGO-free SQLite: a static binary on a distroless image and a straight cross-compile to arm64. Sessions use 15-minute JWTs with rotating refresh tokens in HttpOnly cookies.
  • Shipped as a fleet: each version tag runs the tests and only then publishes amd64 + arm64 images to GHCR. Scripted provisioning, beta and stable channels, rollback and an offline bundle for plants without internet.
containerized services
0
architectures: amd64 and arm64
0
automated tests
0+
port exposed to the plant
0
  • Go
  • Gin
  • SQLite
  • Python
  • FastAPI
  • Modbus TCP
  • React
  • Docker
  • GitHub Actions

ISA architecture: the equipment's PLC talks Modbus TCP only to core-isa, which relays readings over HTTP to pid-service and over WebSocket to the Go web-backend. The web-backend stores data in SQLite and is published by the web-frontend's nginx, the only port open to the operator's browser. Everything runs on Docker Compose on a Raspberry Pi 5 or an industrial PC.

02 ■ Commissionsin production

Commissions

2026 — presentBack-end · Comber

Internal system that records sales and receipts and calculates sales commissions, with registries, a dashboard and PDF and Excel reports. A TypeScript API on PostgreSQL that also serves the front-end.

  • A 51-requirement PRD written before the first line of code. New features follow a spec with traceable criteria and independent verification, mutation testing included.
  • Layered Express 5 API (route, controller, service, repository), Zod-validated input, and identity always taken from the token, never from the request body.
  • The API serves the React build from the same origin: one port, no hard-coded IP and the same build on a laptop or the server. HttpOnly cookies, a Helmet CSP and rate limiting on login.
  • 524 tests with Vitest and Supertest. The 43 route suites run against an isolated test Postgres, and the config refuses to start without it because the tests wipe tables. CI repeats it all on every PR, with lint, typecheck and migrations.
PRD requirements
0
automated tests
0
integration suites
0
port for API and front-end
0
  • TypeScript
  • Node 24
  • Express
  • Prisma
  • PostgreSQL
  • Zod
  • React
  • Vite
  • Vitest
  • Docker

Commissions architecture: the browser calls /api on the same origin; the Express API serves the React build and reaches PostgreSQL through Prisma, all in one container on one port. In CI, GitHub Actions runs lint, typecheck, migrations and tests against an isolated test Postgres.

Engineering

Inside whatI built

The systems behind the numbers, animated from the real code. Plant names and calibration values are left out.

01 ■ Real timelive

PLC fan-out over WebSocket

A single owner of the Modbus connection reads the PLC once per second and streams the same reading to the supervisory UI and the adaptive tuning service.

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

Animated diagram: the PLC accepts a single Modbus TCP connection. core-isa is the only owner of that connection, reads the PLC once per second and streams the same reading over WebSocket to two consumers: web-service, the supervisory UI in Go with Gin and SQLite, and pid-service, which does adaptive tuning in Python. More open browsers add no extra traffic on the PLC.

02 ■ pid-service · deterministiclive

Tuning by rules and rails

Each episode measures overshoot, oscillation, offset and saturation. The first matching rule adjusts P, I and D, always within ±30% and the bounds.

  • Python
  • NumPy
  • Ports and adapters
  • 5-min episodes

Animation of three tuning episodes. Each episode holds 300 temperature samples (about 5 minutes), cleaned by a median-of-3 filter. From the first setpoint crossing on, the regulation window, it measures overshoot, undershoot, oscillation and offset (standard deviation and mean of the last quarter) plus the share of saturated Hz, combined into a weighted score where lower is better. Rules run in this order and the first match decides: 1, overshoot or undershoot, raise D and lower P; 2, Hz saturated or sweeping the range, lower P and raise D; 3, oscillation, lower P and I; 4, offset below setpoint, raise I and P slightly; 5, offset above, lower P and I; otherwise keep the PID. The suggested PID then goes through the rails: at most ±30% per episode and within bounds. In the example, episode 1 overshoots and the suggested D hits its bound; episode 2 oscillates; episode 3 is within tolerance and the PID is kept.

03 ■ pid-service · machine learninglive

Random Forest over history

After 20 steady-state episodes, an 80-tree forest predicts the score of 125 P, I, D combinations around the current one and picks the lowest.

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

Animation of the pid-service machine learning layer. While history holds fewer than 20 steady-state episodes, the deterministic rules decide. At 20, an 80-tree RandomForestRegressor is trained on P, I, D, level and setpoint to predict the episode score. It scores a 5 × 5 × 5 grid of 125 candidates, each gain from −30% to +30% of the current PID, and picks the lowest predicted score (argmin). The suggestion goes through the same rails as the rules, ±30% per episode and bounds, and is only applied in drive mode; in shadow it is just logged and off disables the layer. If the predictions are nearly tied (spread under 1%), the rules decide. The loop alternates between two operating profiles.

04 ■ Side project · Golive

Guardian, a zero-knowledge vault

The master password never leaves the machine. The client derives the keys and encrypts every item; the server only stores opaque blobs it cannot read.

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

Animated diagram of Guardian, a zero-knowledge password manager. The master password goes through Argon2id into the master key, which HKDF-SHA256 splits into an auth hash and an enc key. Only the auth hash goes to the server, which stores an Argon2id of it. The enc key never leaves the client: it opens the vault key with AES-256-GCM, and the vault key seals every item, name included, with AES-256-GCM and AAD bound to the user and the item. The server only receives and stores opaque blobs in PostgreSQL.

Stack

The languagesI use every day

Three languages, each where it pays off most: Go for services, TypeScript for web apps and Python for data and talking to the PLC.

Go

go 1.27 · production

Simple concurrency with goroutines and a single binary with no runtime to install, which makes it great for network services. I use it for a web supervisory system on Gin + SQLite (REST + WebSocket, JWT with rotating refresh tokens, rate limiting) and for Guardian, a zero-knowledge password manager with a 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

Types catch the bug before it reaches production, and Bun rounds it out as a fast runtime with its own bundler and test runner. In the commissions app, the API runs on Express, Prisma and PostgreSQL, with automated tests and CI on 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 · data + PLC

A mature scientific ecosystem: linear algebra, statistics and machine learning without reinventing anything. I use it for the adaptive tuning service (NumPy and a scikit-learn random forest), built with ports and adapters, and for the core that talks to the PLC over Modbus TCP.

  • NumPy
  • scikit-learn
  • httpx
  • pymodbus
~/app — zsh
$ python3 -m venv .venv && source .venv/bin/activate
Also in the toolbox
  • Docker
  • GitHub Actions
  • PostgreSQL
  • SQLite
  • nginx
  • Raspberry Pi
  • Linux
Awards

FIAP Hackathonwinner

First place at Global Solution Future at Work 2025, the FIAP hackathon held on November 11, 2025.

FIAPglobal solutionFutureAtWork

FIAP University Center certifies that

Guilherme Alves Rodrigues Ferreira

Won the Global Solution Future at Work 2025, held on November 11, with a workload of 2 hours.

1st place · Hackathon11.11.2025

A FIAP challenge themed Future at Work: think up, build and pitch a tech solution for the future of work, against the clock. The project took first place in the 2025 edition.

  • Hackathon
  • FIAP
  • Future at Work
  • 2025
Original certificate · FIAP
FIAP certificate: Guilherme Alves Rodrigues Ferreira won Global Solution Future at Work 2025, held on November 11, with a workload of 2 hours.
Education

Academicbackground

Software Engineering, at FIAP and now at UniRV.

  • 2026 – present

    B.Sc. in Software Engineering

    UniRV · Universidade de Rio Verde

    in progress

  • 2024 – 2025

    B.Sc. in Software Engineering

    FIAP

    ended

Let's buildsomething real-time?

Open to back-end developer opportunities.

Email
guialves.garf50@hotmail.com
Send an emailLinkedIn(opens in a new tab)GitHub(opens in a new tab)Instagram(opens in a new tab)

@guialvesrf everywhere