Mykola Vorobiov - Senior Python Developer & System Architect

Profile

I don't ask domain experts how the software should work — that overconstrains the problem. I ask what makes the result good, then find an architecture that delivers it. Over 20 years in software, 8+ years of Python, and complete production systems built solo: at SignalsAPI I created the entire technical stack for a B2B platform — 30+ microservices handling 1M+ daily operations at 99.9% uptime, monitoring 457+ job board sources that break daily and recover themselves. Architecture, implementation, deployment, and ongoing operations, from zero to production-ready scale.

Systems Built Solo

SignalsAPI Senior Backend Developer & System Architect | Nov 2021 – Present

Recruitment agencies need to spot hiring demand in real time, but job postings are scattered across hundreds of sources that constantly change. Built the complete technical foundation as the sole developer.

Built a self-healing platform monitoring 457+ job board sources across 30+ microservices handling 1M+ daily operations; at this scale sources break daily and the system detects and recovers automatically
Initially assumed every agency's process was unique; by building and iterating with multiple customers, found the standardized pipeline that works universally — the invariant beneath the surface variation
Used the platform to find my own leads, sold results as a productized service, then transitioned to SaaS once proven
Architected 30+ Python microservices (FastAPI, AsyncIO, SQLAlchemy 2.0) with event-driven processing via RabbitMQ
Developed scraping infrastructure with 95% success rate on protected sites; self-healing parsers processing 1M+ daily data points
Multi-agent AI pipeline cut client onboarding from 5 days to 3 hours
Bare-metal Docker infrastructure with 70% cost reduction vs cloud, no DevOps team and 99.9% uptime
Reached the first paying client three months from the first line of code via a founder-brought pilot

Stack: Python, FastAPI, PostgreSQL, pgvector, LangGraph, RabbitMQ, Docker, Playwright, Grafana, Prometheus

A scientific-research knowledge platform Sole Technical Owner | Mar 2026 – Present

A research team had deep domain expertise, no technical capacity, and no way to translate their mental models into software.

Converted ~15 PhD-level scientists' deep domain expertise into structured, queryable knowledge for a neuro-symbolic AI system
Sole technical owner embedded as the only engineer in a team of 15, with full lifecycle ownership while the scientists focus purely on their domain
Enabled researchers to produce knowledge graphs within days
Kubernetes-native platform turning a document corpus into a live, queryable knowledge graph — RDF triples in Apache Jena Fuseki/TDB2 plus vector embeddings in Milvus — served through an epoch-fenced SPARQL API and a hybrid semantic-search endpoint
Retired a hand-operated EC2 deployment: SSH sessions into boxes, instance resizing between ingest and serving phases, hand-edited security groups and ad-hoc secret plumbing replaced by scripted recipes, a token-authenticated control-plane API with a CLI, and CI-proven charts, so operators and tenant developers never touch the cluster
Introduced CI/CD, automated testing, and containerized deployment to a research codebase — cut release cycles from weeks to days

Stack: Python, FastAPI, Knowledge graphs, RDF/SPARQL, Apache Jena Fuseki, Milvus, Kubernetes, Terraform, Next.js, Docker, CI/CD

Virtual BDR — Automated Outbound Sales Machine Architect & Sole Developer | 2026 – Present

SignalsAPI finds the signals, but someone still has to act on them — reach out, follow up, warm up, get meetings booked. That is a human BDR's job, and it is expensive and inconsistent.

Codified the entire BDR workflow — prospecting, LinkedIn outreach, email sequences, follow-ups, nurturing — into modular, reusable building blocks
Built as LEGO blocks, not a monolithic flow: same blocks, different compositions for different clients, and the abstraction is what makes it client-independent
Multi-persona orchestration deploying parallel campaigns across distinct buyer personas with independent messaging and cadence

Stack: Python, LinkedIn automation, Email sequencing

KIMA — AI Employee for Real Estate Agents Architect & Sole Developer | 2025 – 2026

German real estate agencies run different CRM systems with different APIs and different sales processes, and every agency's workflow looks unique on the surface.

Diagnosed the consistent domain-expert mistake — translating a manual process directly into software, which overconstrains the problem because humans and software think in fundamentally different categories
CRM-agnostic intelligence layer on a two-queue architecture: inbound adapters translate CRM events into standardized signals, business rules decide what should happen, outbound commands act back on the CRM
The same find-the-invariant, abstract-the-chaos approach applied to an entirely different domain and an entirely different technical shape — event-driven CRM orchestration rather than web scraping pipelines
Delivered a working system into the agencies' hands two months from the idea

Stack: Python, Event-driven architecture

Ush — AI Meeting Scheduler Architect & Sole Developer | 2025 – 2026

Executive assistants pick meeting slots using dozens of implicit factors — habits, travel times, meeting importance, the other party's constraints. That logic lives entirely in their heads and cannot be delegated or scaled.

Deconstructed scheduling decisions into explicit, weighted parameters and turned scheduling into a constrained optimization problem
Deterministic slot scoring: the LLM only generates explanations while a transparent matrix-scoring engine produces candidate slots, so scheduling is debuggable and reproducible
Real-time travel time and location awareness: factors commute between meetings and suggests slots that minimize dead time
Vendor-agnostic LLM layer with OpenAI, Gemini and Claude as interchangeable adapters, enabling A/B benchmarking and cost control without touching business logic
Multi-tenant isolation by construction: every query scoped to an explicit user_id via a UserContext pattern, with no cross-tenant leakage
Shipped a product that replaced the stakeholders' UI mockups entirely, solving what they needed rather than what they drew
Shipped the first beta in one month with the system genuinely usable four months in

Stack: Python, Flask, PostgreSQL, OpenAI, Google APIs, Docker

The Pattern

Five production systems across five unrelated industries, each built solo by extracting tacit knowledge from domain experts and making it computable. One method, one engineer, repeated proof of transfer.

System	Tacit knowledge source	Made computable as	Domain
SignalsAPI	"How to find good leads"	Scraping and classification pipeline	recruitment
Virtual BDR	"How to work a prospect"	Composable outreach modules	sales
KIMA	"How to manage deals in a CRM"	Event and command queue orchestration	real estate
Ush	"How to pick the right meeting slot"	Weighted constraint optimization	executive scheduling
A research knowledge platform	"What we know about this domain"	Knowledge graphs for AI	scientific research

The constant: tacit → explicit → computable → production. Solo.

The Method

Start with direction, not requirements. Stakeholders describe what they're thinking. No brief. No "how should the software work" — because they don't know, and asking forces premature decisions.
Build to think. Instead of extracting requirements through questions, build a working prototype that embodies the idea. Show it. The prototype becomes the conversation — stakeholders react to concrete software, not abstract specs. The building is the requirements process.
Iterate to surface the real priorities. Each cycle reveals what actually matters. Features stakeholders thought were critical often turn out to be later work. More important things emerge that couldn't have been articulated upfront.
Find the invariant pattern. Beneath 457 different job boards, or 5 different CRMs, or every executive assistant's unique habits, there is always a universal shape. Find it, abstract it, build around it — that is what makes the system scalable rather than bespoke.
Ship production-grade, solo. Full stack: architecture, implementation, infrastructure, deployment. Bare-metal Docker on commodity servers. No DevOps dependency.

Consulting Engagements

Contract work on existing platform teams — kept separate from the systems above, which were built solo.

A US personal-injury legal-tech platform Architect & Backend Developer | 2026

Personal injury law firms reconstruct a medical chronology by hand from thousands of pages of records before they can write a demand letter.

Delivered the full platform in a one-month engagement, shipping the LangGraph state machine for medical chronology extraction across 11 document categories, Neo4j, pgvector, AWS Textract, GraphQL and spaCy inside that single month
Distributed microservices over RabbitMQ with multi-tenant data isolation for legal compliance
PostgreSQL with pgvector for RAG and Neo4j for entity relationships
Custom token-bucket rate limiter enforcing per-model RPM/TPM with exponential-backoff retries
spaCy for medical term recognition and ICD-10/CPT code mapping

Stack: Python, FastAPI, GraphQL, LangGraph, PostgreSQL, pgvector, Neo4j, RabbitMQ, AWS, spaCy

An enterprise HR-analytics platform Data Platform Engineer | 2025 – 2026

Job market intelligence needs the whole posting market processed continuously, which is a distributed data engineering problem before it is an analytics one.

Distributed ETL on the Ray framework with Apache Iceberg data lake storage
Migrated analytics to ClickHouse, eliminating a data processing lag of roughly 3 weeks
Platform services, workers and API on Amazon EKS (Kubernetes) with Karpenter node autoscaling, IRSA per-pod IAM and ArgoCD GitOps deploys
Amazon MSK as the backbone between tiers: crawlers publish new postings to a Kafka topic and Ray workers consume and process them
Provisioned and versioned the entire AWS footprint as code with Terraform, from the EKS clusters and the data stores through to networking, secrets and observability

Stack: Python, Ray, Kafka, Apache Iceberg, ClickHouse, Redshift, FastAPI, Terraform, Kubernetes

Experience

Backend Developer & Technical Lead

ICOACH 2016 – 2020 | Remote

Learning Management System serving users at scale. Full-stack development with Flask backend, real-time features, and payment integration.

Built a responsive student portal and admin interface using JavaScript, jQuery and Bootstrap
Built ML email classification (scikit-learn) cutting support response time
Designed multi-tenant architecture with data isolation per institution
Optimized critical queries through strategic indexing; reduced server load via Redis caching
Integrated Stripe for subscription management with webhook-driven billing

Stack: Python, Flask, PostgreSQL, Redis, scikit-learn, JavaScript

Freelance Developer

Self-employed 2012 – 2016

Complete Python backend for a large e-commerce product catalog with search, filtering, and payment processing
ETL pipelines processing 1M+ records daily with PostgreSQL optimization and validation
LinkedIn scrapers and browser automation for B2B lead generation

Stack: Python, PostgreSQL

Backend Developer

Kassa Vdoma 2010 – 2012

Implemented fraud detection rules reducing chargebacks
Built PCI-compliant payment APIs processing high monthly transaction volume
Integrated multiple payment providers through a unified interface

Software Architect

Software Development 2001 – 2009

Full-time software architecture and development — the first eight of the twenty-plus years behind this CV.

Technical Skills

Languages & Runtimes: Python, JavaScript

Frameworks: FastAPI, SQLAlchemy, Flask, GraphQL, Pydantic

Databases: PostgreSQL, Redis, pgvector, ClickHouse, Neo4j, Amazon Redshift

Data Engineering: Web scraping at scale, ETL pipeline design, Apache Iceberg, Kafka, RabbitMQ, Ray

AI / ML: LLM integration, Knowledge graphs, AWS Bedrock, LangGraph, Multi-agent orchestration, RAG, scikit-learn, spaCy

Infrastructure: Docker, AWS, Kubernetes, CI/CD, Google Cloud Platform, Terraform

Architecture & Practice: Decision and scoring engines, Multi-tenant architecture, Event-driven architecture, Self-healing systems, Sole technical ownership, Browser automation, Capacity planning and backpressure, Microservices, Third-party API integration, Integration testing against real systems, Composable workflow design, Applicant tracking system integration

Languages

English (C1) • German (B2) • Norwegian (B1) • Ukrainian (Native)

Fit

Good fit: Non-technical founders who need a technical co-founder without giving up equity. Teams with domain expertise and no technical team who need to go from idea to product. Teams drowning in manual processes who need someone to see the architecture they can't. Organizations building AI-native products who need systems thinking, not prompt engineering.

Bad fit: Companies that already have a detailed spec and just need hands to code it. Teams that need someone to manage 10 other developers — I replace the team, I don't manage one. Organizations that want a cautious, phased, committee-approved approach. Anyone who thinks AI means "add a chatbot to the website."