Lucas Matías Frías

Open to senior roles · Remote or hybrid

Lucas Matías Frías

Senior Software Engineer

Architecture, security and distributed systems · Agent-assisted engineering

Eight years building software. Lately, event-driven distributed systems: microservices that talk over queues, signed integrations between platforms, and the infrastructure that keeps them running in production.

I work from judgement, not from tooling. The questions that shape my designs are always the same ones: what guarantees this is correct, what happens when it fails, and who is allowed to reach what.

For over a year now I have been building with coding agents. The work moved from writing code to defining the acceptance criteria and the constraints the result has to clear.

Buenos Aires, Argentina · Remote lucasmatiasfrias@live.com linkedin.com/in/lucasmatiasfrias

8yearsbuilding software, since 2018
7yearsteaching programming at university level
+1yearbuilding with coding agents
3countriesteams in Argentina, Uruguay and the United States
How I work

What I bring to a team is not a language. It is judgement about these five things.

Architecture and design

I split systems for operational reasons, not for fashion. Every boundary has to be justifiable by something that actually happens in production.

  • Extend the tool the business already runs on rather than standing up a parallel system. Almost everything I have built in recent years is exactly that: a module, a channel or a service that plugs into an existing platform through its public contracts, without asking the team to switch tools.
  • Services with independent build contexts, when there is a concrete availability reason: redeploying the UI must not restart the event ingester, which has to keep receiving.
  • Event-driven over a message broker: queue, audit log, dead-letter queue, and domain routing kept separate from ingestion.
  • Ports and adapters where it matters. In the payments prototype, swapping the mocked gateway for the real one touches a single file — neither the domain nor the UI notices.
  • Contract first: the envelope, the enums and the result codes defined before the code that uses them.
  • Control plane separated from data plane, cache-aside, BFF and facade — applied where they solve something, not as a catalogue.

Security

Not a layer bolted on at the end, but the property that decides the shape of the system.

  • Cryptography verified on both ends: 2048-bit RSA-SHA256 signatures with canonical serialisation over a payment envelope. Flip a single byte of the signature and the operation fails with the contract's own error code.
  • Ed25519 signature verification on inbound webhooks, before the event ever reaches the queue.
  • Isolation of untrusted execution: an ephemeral container per turn, non-root user, memory, CPU and process limits, and only the workspace mounted.
  • Separate authentication surfaces: a service-to-service secret compared in constant time, and short-lived user credentials minted by the control plane.
  • Per-module authorisation over an explicit permission catalogue, with roles seeded idempotently.
  • Defence in depth at the edge: a single container with host ports, backends with no public exposure, and internal routes rejected at the proxy.
  • Attack-surface audit of a server: ports listening on all interfaces, authentication logs and authorised keys, with a hardening plan — key-only access, firewall, and secrets moved out of the code.

Reliability and operations

Design for the day something breaks, because it will. What matters is whether you can see it, trace it and replay it.

  • Idempotency and retries with backoff on every integration that crosses a network boundary.
  • Dead-letter queues and an audit log: a failed event can be found, understood and reprocessed.
  • Container healthchecks, structured logs, metrics and active monitoring.
  • Scheduled jobs go to a workflow engine, not to a cron hanging off the server. Every run is recorded with its input, its output and its error, and can be retried without opening an SSH session. A cron that fails at three in the morning leaves nothing behind to explain why.
  • Containerised deployment behind a TLS reverse proxy. Internal services do not reach the internet.
  • Time zones treated as a design decision rather than a default: a system that reasons in the merchant's local time closes the day when the merchant closes.

Methodology and team

Code is half the job. The other half is that someone else can understand it, extend it and trust it.

  • Tests as executable specification, written to define behaviour rather than as paperwork afterwards.
  • Architecture documentation as the repository's contract: a written golden path so every new module is built like the ones before it.
  • Seven years teaching Algorithms and Programming at university level. Explaining a system to someone who does not know it is half of a senior engineer's job.
  • Scrum, peer review and predictable delivery. I work with teams distributed across three countries.
Engineering with agents

I have not hand-written code in over a year. I specify, constrain and verify.

I replaced line-by-line diff reading with verifiable constraints. The work moved from writing code to defining the acceptance criteria: contracts, tests as executable specification, complexity and dependency limits, and an architecture that makes the system verifiable in parts.

Reviewing stopped being reading. It is designing the gauntlet the result has to run before it exists in production. That is not a tool you pick up — it is an architectural decision.

“My current strategy is to not read any of the code written by my agents. […] What I do instead is to surround the agents with extreme constraints.”
Robert C. Martin@unclebobmartin · X · 23 July 2026

The gauntlet, implemented

In the agent-builder module of the apps platform, the security boundary is not the agent's tool restrictions: it is a server-side publish gate — a pristine security lint plus the test suite — that the code has to clear before it can be deployed. The decision is reasoned and written down in the code, not left implicit in configuration.

A capability layer of my own

Around fifty versioned procedures over the APIs I use daily, typed and narrowly scoped, instead of relying on generic functionality. The number is not the point: the governance is. Per-domain credentials with least privilege, in-house standards imposed on the agent, and a real lifecycle — anything replaced is marked deprecated with a pointer to its successor rather than deleted.

A reconstructed contract

A payment gateway publishes its integration manuals as scanned PDFs with no extractable text. The filename gave away the real provider, which does document in text. From there: contract reconstructed, cryptographic signature verified on both ends, and tests that exercise it.

Portfolio

Five systems. Almost everything I know how to do is in the first two.

Fluxing LLC · own product

Business automation platform

The authentication and licensing server for the desktop application: signed credentials, bcrypt hashing, a server-side session for the admin panel and an audit trail of every access attempt. Around it, the product's synchronisation and orchestration services.

  • Python
  • FastAPI
  • SQLAlchemy
  • JWT
  • Docker
Software engineering · 2024–2026

A messaging provider of my own

An instant-messaging channel built from scratch on the Baileys library and registered as a native provider of the CRM: it holds the session, reconnects, sends and receives through the platform's API, and publishes every message onto the broker for the asynchronous microservices to process. Three languages talking over queues, with signed webhooks, idempotency and retries with backoff.

  • Node.js
  • Fastify
  • Baileys
  • Java 17
  • Spring Boot
  • RabbitMQ
  • PostgreSQL
Roche · 2022–2024

Data and natural language over the warehouse

A Python library published on PyPI to reach several corporate data warehouses through a single client. A chatbot that turns natural-language questions into executable SQL against those warehouses and answers with the results. ETL processes, analytics dashboards, and reverse engineering of public APIs to bring external data in.

  • Python
  • FastAPI
  • SQLAlchemy
  • SQL Server
  • SSIS
  • Tableau
Experience

Where I have been, and what I built there.

May 2026 — present

Project Manager

Otimify

Montevideo, Uruguay · remote

Project management across the agency's operation and, in parallel, design and construction of the in-house apps platform that extends the CRM it runs on.

Feb 2026 — present

Co-Founder

Fluxing LLC

United States · remote

An in-house business automation product. Architecture, backend, authentication and licensing, infrastructure and deployment.

2019 — present

Programming Lecturer

Universidad Nacional de José C. Paz

Buenos Aires, Argentina

Introduction to Programming, and Algorithms and Programming, in the BSc in Information Technology Management.

Mar 2024 — Feb 2026

Software Engineer

The Old School Services

Buenos Aires, Argentina · remote

Designed, built and operated event-driven microservices in Java 17, talking over a message broker and collaborating with Node.js and Python services. Integrated SaaS platforms through APIs and signed webhooks defined contract-first, with a strong focus on resilience — retries with backoff, idempotency — observability and security. Built a custom instant-messaging provider, registered as a native channel of the CRM, that holds the session, sends and receives through the platform's API and publishes every message onto the broker for the asynchronous services to process. Agents running in production for sales and appointment scheduling.

Mar 2022 — Oct 2024

Data Engineer

Roche

Buenos Aires, Argentina

ETL processes, SQL Server administration and modelling over relational databases. A Python library published on PyPI unifying access to the company's data warehouses. Scraping and reverse engineering of public APIs to bring external data in, a natural-language-to-SQL chatbot, and analytics dashboards.

Aug 2018 — Sep 2025

LMS Administrator

Universidad Nacional de José C. Paz

Buenos Aires, Argentina

Administration, configuration and deployment of the university's virtual campus. Site frontend, relational databases, ad-hoc reporting and a custom client against the platform's REST API.

Mar 2018 — Aug 2018

Website Administrator

Argentine National Secretariat of Modernisation

Buenos Aires, Argentina

Frontend of the institutional site, LAMP server administration, and the database behind the public examinations system.

Education

Degree, certifications and languages.

Degree

  • University Programmer AnalystUniversidad Nacional de José C. Paz
    2016 – 2019

Certifications

  • Denodo — Data Virtualization, Denodo Essentials, Platform Installation and Data Modeling (2022)
  • Object-Oriented Design — EscuelaIT (2020)

Languages

  • Spanish — native
  • English — B1

What I have worked with

Tools are context for the systems I built, not the skill itself. They are here for whoever is looking for them.

Languages
Java · Python · JavaScript · TypeScript · Dart · SQL
Backend
Spring Boot · FastAPI · Node.js · Fastify · Express · SQLAlchemy
Data
PostgreSQL · SQL Server · MySQL · MariaDB · Oracle · SSIS · Tableau
Integration and messaging
RabbitMQ · REST · OpenAPI · Signed webhooks · WebSocket · n8n
Infrastructure
Docker · Docker Compose · nginx · Caddy · Linux · Git · CI/CD
Security
RSA · Ed25519 · JWT · OAuth 2.0 · bcrypt · RBAC · Container isolation
Frontend and mobile
Flutter · React · Vite · HTML · CSS
AI
Claude Code · MCP · OpenAI API · LLMs in production
Contact

Lucas Matías Frías

Open to senior software engineering roles, remote or hybrid.