Evgeny Zhdanov

Senior Software Engineer | Technical Lead

Professional Summary

10 years of professional experience in software engineering, Go and Ruby/Rails. Last 2 years as team lead — roughly 40% code, 60% architecture and coordination. Built payment processing integrations, HR automation platforms, and the teams around them. Looking for roles where I own technical decisions and ship with a small team.

Founder and core maintainer of OpenTalon (github.com/opentalon) — a production-grade open source AI orchestration platform in Go (Apache 2.0) for safe LLM integration into enterprise workflows: multi-provider routing (OpenAI / Anthropic / DeepSeek), prompt injection prevention, isolated gRPC plugin architecture, MCP integration. Co-author of Talon, a Prolog/Datalog-inspired logic programming language for expert systems with built-in ML primitives — writing its compiler in Go (lexer, parser, query planner, runtime).

Engineering philosophy: I don't trust theory disconnected from production. I work across the stack and pick up whatever the problem requires — language, protocol, or tool. I hire quiet engineers who deliver over charismatic ones who write reports. I build processes because processes breed discipline.

Employment History

Founder & Core Maintainer — OpenTalon — open source AI platform (github.com/opentalon)

May 2025 — Present

Tech stack:

Go, gRPC, Protobuf, LLM APIs (OpenAI / Anthropic / DeepSeek), MCP, Datalog/Datalevin, PostgreSQL, SQLite, Kubernetes, Helm, GitHub Actions

Product:

Production-grade open source platform for safe LLM orchestration and AI agents in enterprise workflows, written in Go (Apache 2.0). An alternative to commercial LLM orchestrators.

Key achievements:

Founded and lead OpenTalon — own the architecture, technical direction, and public roadmap of the platform.
Built enterprise-grade LLM orchestration in Go: multi-provider routing (OpenAI / Anthropic Claude / DeepSeek) to control model spend, deterministic preprocessing, plugin isolation, and policy enforcement — everything a single large LLM call can't give you.
Core architectural idea — "the LLM writes code, the runtime keeps it safe" (after Cloudflare's Code Mode for MCP): the model emits scripts in the restricted Talon DSL rather than raw tool calls. The grammar physically cannot express an unsafe operation, so the sandbox is structural, not a policy we hope the model follows.
Implemented prompt injection prevention: every LLM request passes a security check first, and guard plugins sanitize tool results before the model sees them — covers the key OWASP LLM Top 10 risk, so one compromised integration can't poison the model context or reach other plugins.
Designed the plugin architecture for isolation: plugins are separate OS processes over gRPC + Protobuf, memory-isolated from the core, with no privilege escalation or lateral movement between plugins. Channel-aware auth for Teams/Slack scopes data and tool access per channel and user.
Built a content preparer / deterministic preprocessing layer: business validation before the LLM call — saves tokens, cuts latency, and moves compliance rules out of the prompt and into testable code. Integrated MCP (Model Context Protocol) as a fact source plus a host scheduler for periodic work.
Built opentalon-agents (persistent LLM-authored agents): the user describes a task in chat, the LLM writes the logic in Talon once, and the plugin executes it autonomously with no model at runtime — authoring is probabilistic, execution is cheap and deterministic. Edge-triggered watcher over EAV fact triplets with snapshot state for restart-safe runs; poll, webhook, and cron triggers with backoff. External gRPC plugin with its own state in SQLite/Postgres, everything group-scoped.
Co-author of Talon (github.com/opentalon/talon-language) — a declarative logic programming language inspired by Prolog/Datalog where rules read like English, so a domain expert can write and audit them without programming; the engine does forward inference over facts. Rule blocks: detect, forecast, recommend, rule — with predicates, Or/Not, full-text, aggregates + GroupBy, and rule-calls-rule.
Writing the Talon compiler in Go: lexer, parser, validator, query planner, runtime — with an AST, a query optimizer over Datalevin plans, a REPL, and a rule testing framework (.talon.test). FactStore on Datalevin (native Datalog, FTS, raft); every detection is explainable and auditable, returning a trace of which facts, which rule, which threshold.
Built lightweight ML primitives as language keywords (anomaly detection, forecasting, clustering, classification) — statistical primitives that run in milliseconds over structured data, with thresholds adaptively learned per tenant. Targets compliance-heavy domains (finance, insurance, healthcare, legal) and asset/fleet maintenance: the LLM parses unstructured input, deterministic rules guarantee regulatory compliance and escalation.

Software Consultant — Self-Employed

May 2025 — Present

Tech stack:

TypeScript, React, Ruby/Rails, Kubernetes, Helm, GitLab CI

Product:

Contract software development, technical consulting, and code review for software teams and returning clients.

Key achievements:

Part-time contract work on an online music notation/tablature editor (TypeScript, frontend + backend) — 6-month engagement, hourly rate. Leveraged AI-assisted development with Claude for accelerated delivery.
Migrated legacy Ember.js application to React for a returning client (Magtuner) — project originally built in 2016. 3-month engagement using AI-assisted workflow: structured migration with markdown artifacts for continuity, rewrote all business logic to modern React.
Led FB/IG widget system project: end-to-end development, deployed via Helm to Kubernetes, set up GitLab CI/CD pipeline from scratch. Mentored an 18-year-old CS student on the project as per client requirements.
Hardened CI/CD for Ruby projects: configured rubocop, brakeman, and strong-migrations for automated code quality and security checks. Separately upgraded another project to Rails 8.1.
Open source: published copy_with_context.nvim (Neovim plugin) and tinylist (Kubernetes email API service).
Published 10+ engineering articles on zhisme.com.

Team Lead — RocketWork

November 2023 — May 2025

Tech stack:

Ruby/Rails, Go, React, PostgreSQL, Kubernetes, ArgoCD, GitHub Actions, Grafana, Kibana, Sentry

Product:

B2B HR automation — configurable personnel management system (hiring, offboarding, leave, document signing) for enterprise clients.

Key achievements:

Took over a frozen product — codebase existed but had never reached production. Shipped it to paying customers as a single engineer, then built a team of 5 (4 devs + 1 QA).
Built the entire dev process from scratch: Jira ticket workflow (everything is a ticket), Git Flow, code review with <24h turnaround, weekly release cycle via Helm + ArgoCD to Kubernetes.
Designed configurable HR workflow system — each company needs different forms, approval chains, and data fields for the same process (e.g., "hiring" varies per org). Built JSON-driven form constructor so non-developers configure workflows from admin UI, React frontend consumes the schema.
Picked up and shipped a Go microservice for electronic document signing (CryptoPro PDF signatures + watermarks) — was left unfinished by the previous team. Added PDF parsing, logging, request tracing, deployed to production.
Defined application-level observability: configured Yabeda Rails metrics, business KPI dashboards in Grafana (completed workflows, document signatures, delivery rates), request trace_id in Kibana for end-to-end debugging, Sentry for error tracking. Infrastructure setup handled by DevOps team.
Hired and managed 3 engineers — conducted technical interviews, onboarded, and directly led the team: assigned tasks, guided technical decisions, and unblocked problem-solving day-to-day.

Senior Software Engineer — Emerchantpay

January 2021 — November 2023

Tech stack:

Ruby/Rails, MySQL, React, Elasticsearch, Jenkins, Docker, AWS

Product:

Payment gateway serving 10,000+ merchants across multiple banking integrations. Large-scale Rails application with long production history.

Key achievements:

Built LATAM bank integrations from scratch — first one took 3-4 months. Consumed external XML/SOAP APIs for transaction processing, SFTP batch transfers with PGP encryption (private/public key pairs), Sidekiq cron for transaction state synchronization. Configured web payment forms for card payments on integrated providers.
Implemented transaction reconciliation: automated verification of amounts and states across systems where status could update from multiple sources. Processing, reconciliation, and cancellation flows across different bank APIs.
Fixed security vulnerabilities found in audits: path traversal on SFTP server (CWE-22), injection via unescaped quotes in XLSX parsing.
Incremental legacy cleanup during feature work — updating base classes, removing dead code. Not a grand rewrite, just responsible engineering in a codebase where touching anything unrelated could break live payments.
Mentored 3 junior developers through code reviews and pair programming.

Software Engineer — Noveo (outsource for a major French retail analytics company)

June 2018 — January 2021

Tech stack:

Ruby/Rails, React, TypeScript, MongoDB, MySQL, Redis, Elasticsearch, Docker, GitLab CI

Product:

Enterprise customer feedback platform — survey collection and analytics for retail chains.

Key achievements:

Migrated analytics from MongoDB to Elasticsearch, reducing dashboard load from ~2 minutes to 5-10 seconds for graphs and histograms over retail feedback data.
Refactored legacy codebase — extracted fat controllers/models into service objects. Client funded a second phase: rewriting the end-user questionnaire module to React + Rails API with modular architecture, after we'd already rebuilt the admin constructor.
Implemented SAML 2.0 SSO — designed DB schema for federated users so corporate clients authenticate via their identity providers (Okta, Azure AD) without separate credentials.
Mentored 3 interns through code reviews and pair programming; 2 were hired afterwards.

Junior Software Engineer — Magtuner SA (Lausanne, Switzerland)

March 2016 — May 2018

Tech stack:

Ruby/Rails, Ember.js, Elixir, WebSockets, MySQL, Redis

Product:

Real-time educational engagement platform with live audience participation.

Key achievements:

Built collaborative editing lock/unlock system in Elixir for concurrent user access.
Built full-stack CRUD features (Ember.js frontend + Rails backend) and implemented document ACL permission system controlling access to shared resources.
Supported live events including Children's Olympics (~50 concurrent WebSocket connections).