Cosmin – Python, LangChain, OpenAI

An AI-enabled recruitment marketing platform that distributes jobs across 5,000+ channels in 100+ countries. The product supports multiple product streams and combines backend and frontend workflows for job distribution, candidate engagement, and recruiter productivity.

• Built a real-time interview assistant that joined Google Meet as a third participant via Recall.ai, streamed live transcripts through webhooks into Django, ran turn-by-turn analysis with OpenAI, and delivered private spoken hints to the interviewer through ElevenLabs TTS injected back into the call; the candidate and interviewer shared the same session, while only the interviewer heard the hints;
• Built a career site crawler and RAG pipeline: Firecrawl ingested job listings from client career pages on a cron schedule, OpenAI embeddings indexed them into Pinecone, and a chat widget embedded on the client’s own site let candidates upload their CV and get matched roles back via k-NN retrieval plus a completion call; high-confidence matches routed directly to the job URL, removing the need to browse job boards;
• Built a candidate assessment pipeline covering text and audio input, multi-criteria scoring (skills alignment, communication quality, role fit), and graceful audio session recovery via Retell when connections dropped mid-interview; delivered a language assessment MVP for a major European client: chat-based screening through to a PDF dossier with embedded scores for vocabulary, fluency, semantics, and coherence, exportable directly from the recruiter review queue in VONQ EQO;
• Drove AI adoption across the engineering team: introduced Claude and Cursor workflows, multi-agent code review patterns, and blueprint-first agentic development that compressed multi-week tasks into hours.

An AI-driven decision engine for competitive online poker tournaments. The platform combines game-theory-optimal play and reinforcement learning inference to recommend actions and expected value outputs under strict response-time constraints, with a Python FastAPI orchestration layer routing game states across three sibling decision services and a C++ Drogon inference server running RL models in process.

• Maintained and extended a polyglot microservice mesh: a Python/FastAPI glue service routed live game-state requests across a GTO service, a Strategy service, and a C++ RL inference server, each producing action recommendations and expected value scores under a hard response-time budget;
• Extended Acebench, a Python MLOps benchmark that exercised the full stack end to end, detecting strategy regressions and tracking quality and latency improvements against historical baselines, automated via Bitbucket CI pipelines so every push produced a measurable signal, not just a green build;
• Contributed to the C++ Drogon inference server: model loading at startup, low-latency request handling, and integration with the Python orchestration tier over HTTP.

An enterprise desktop platform that enables users to give LLMs executable business logic through discrete, type-safe Python functions. Before MCP became standardized, the platform solved the same problem with its own protocol: an Action Server on FastAPI scans action packages at startup, builds a Pydantic-backed OpenAPI spec, and exposes typed endpoints for the desktop chat app to drive the tool-use loop.

• Led a team of 5 Python engineers from architecture to production on the Action Server and the AI Actions gallery; designed the full authoring-to-invocation pipeline: developers annotate Python functions, Action Server loads and validates them at startup, exposes typed endpoints, and Sema4.ai Studio drives the LLM tool-use loop against those endpoints;
• Designed the OAuth2 flow for third-party service connections, covering the authorization code grant and token lifecycle across Studio, Action Server, and external SaaS providers;
• Migrated the library ecosystem from Robot Framework RPA conventions to idiomatic native Python, improving developer experience and lowering the barrier for contributors without an automation background;
• Redesigned the engineering hiring code challenge to filter on both technical depth and problem-solving approach, cutting poor-fit candidates before live interviews;
• Held external talks on Python automation and the platform's tooling to developer audiences, building awareness for the open-source ecosystem;
• Navigated a turbulent Python-only product pivot while mediating opposing technical views from senior engineers and keeping delivery on track throughout.

An open-source Python automation framework and library ecosystem used by a 10,000-user community of developers and enterprise automation teams. The stack covers the full execution lifecycle: an environment manager builds isolated Python environments and handles deployment; a task runner bootstraps execution through a decorator-based entry point; and a layered library suite supports web automation, desktop and OCR automation, PDF processing, OAuth2 email, cloud API wrappers, and work item plumbing.

• Built and maintained the core library families across six domains: browser automation (Selenium, Playwright), desktop automation and OCR, PDF and document processing, cloud integrations (AWS, Google, OpenAI, HubSpot), work item and secrets management, and structured execution logging with artifact output;
• Resolved a long-standing upstream issue in the OSS project that the team had considered unsolvable, unblocking a class of Windows automation users across the community;
• Owned PyPI package development end to end: API design, versioning, dependency management, and cloud-based integration testing coverage across library releases;
• Contributed to a public gallery of use-case-driven example robots, giving the community a reference layer on top of the raw library surface;
• Committed fully to customer support threads and calls across two years, diagnosing and fixing what burned most for enterprise users; manager feedback: "the support work had massive impact on the entire company's growth and retention."

An e-commerce helpdesk platform for Shopify merchants, enabling support automation across their customer base. The work laid the technical foundation for a developer ecosystem: a registration and review portal for external developers, plus an OAuth2 Authorization Code Grant server built with Flask and authlib to issue scoped access tokens for third-party integrations. Auth0 handled merchant SSO separately and did not participate in third-party token issuance; PostgreSQL stored helpdesk data and all OAuth state, including client registrations, authorization codes, access tokens, and refresh tokens.

• Led the Developer Experience team and laid the technical foundation for the App Store: designed the app registration flow, review gate, and OAuth2 server from scratch, enabling external developers to publish and monetize integrations directly inside the Gorgias platform;
• Built the OAuth2 Authorization Code Grant server using Flask and authlib, covering the full flow: front-channel browser redirect to the authorization endpoint, authorization code issuance, back-channel code-for-token exchange at the token endpoint, and token refresh; kept Auth0 strictly isolated to merchant SSO, with no overlap in the third-party token path;
• Improved the Gorgias REST API surface and developer documentation, reducing integration friction for external partners and accelerating partner onboarding;
• Grew the Developer Experience team while maintaining a startup pace: fast decisions, direct feedback, and a bias toward customer impact over process.

A software platform for smart office buildings, managing sensor-based events across occupancy, HVAC, and access control systems. The architecture supported a mixed-language engineering team shipping services independently while frontend clients stayed on plain HTTP/JSON, using a Go gRPC-gateway reverse proxy with Protobuf spec-first contracts. A parallel track delivered a Mapbox-compliant geolocation API for BMW campus navigation in Germany, with spatial queries backed by PostGIS.

• Established the architecture and code layout for the polyglot microservice mesh: a Go gRPC-gateway reverse proxy transcoding HTTP/JSON to gRPC, three language-specific service implementors (Go, Python, Node.js), and per-service Protobuf contracts enabling independent development across teams;
• Introduced spec-first development: Protobuf definitions were written before implementation, allowing the frontend to work against the gateway with mock responses while backend services were still in progress; eliminated the integration bottleneck that typically serializes FE and BE delivery;
• Built a Mapbox-compliant geolocation API for BMW campus navigation, with all spatial logic implemented at the database layer using PostGIS; delivered Mapbox-compatible query responses without a separate geocoding service;
• Led the team through the delivery: set direction, maintained SLA commitments to clients, and kept communication clear across a distributed engineering group handling concurrent priorities.

A biotech platform that helps researchers find high-quality DNA primer pairs for PCR experiments and detect specific organisms in biological samples. In a domain where accuracy is critical, the backend automated the full primer design pipeline by orchestrating NCBI Blast and Primer3 against GenBank sequence data, filtering candidates, and returning ranked pairs most likely to succeed in wet-lab conditions. It was built on async Python to handle the latency of external bioinformatics tool calls without blocking.

• Built the backend pipeline automating PCR primer design: ingested target DNA sequences, submitted queries to NCBI Blast for homology search, piped results through Primer3 for primer pair generation, and filtered candidates against GenBank data to rank pairs by specificity and amplification likelihood;
• Implemented the async execution model using Python 3 and , handling concurrent calls to external bioinformatics tools without a synchronous bottleneck; external tool latency made this a hard requirement, not a nice-to-have;
• Transitioned mid-engagement from individual contributor to part-time lead: ran technical brainstorms, scoped tasks, and maintained documentation as the team grew.