We are building a web platform for investment portfolio management: assets, transactions, cash flows, market and historical data. Architecture is microservice-based. A defining feature is client-side encryption of sensitive data: the backend stores and processes encrypted fields and does not decrypt them on the server.
In parallel we are building an internal LLM-powered coding layer: a developer describes a task in natural language, the system retrieves context from a knowledge graph and vector search, a coding agent with tooling extensions (MCP-style) generates changes in a dev copy of the main application, followed by human review and merge. The LLM is self-hosted (for example an OpenAI-compatible endpoint backed by a local inference stack), so sensitive data does not go to third-party cloud APIs - that is part of the security model.
Stack (reference)
- Main application: React, TypeScript, a major UI library, Apollo Client; GraphQL API on Node.js (Apollo Server), Mongoose, MongoDB, WebSocket subscriptions.
- Data services: Node.js, Express, Prisma, PostgreSQL (historical FX rates, historical asset prices).
- Options and market data: Python, FastAPI, async, scraping and browser automation where needed.
- Shared client packages: API types, crypto helpers.
- AI coding layer: Python (FastAPI, WebSocket), Docker Compose, graph database, vector store, Redis, MCP-style tool servers, repository indexing, LLM integration via an OpenAI-compatible API.
Responsibilities
- Build and maintain the core web application: frontend and GraphQL backend, features and fixes, API and contract design.
- Evolve Node.js microservices: REST, Prisma, integrations with market data sources.
- Maintain and extend the Python service for options and related flows (FastAPI, async, reliability).
- Work on shared libraries and keep contracts aligned between the main app and services.
- Grow the AI coding layer: task orchestration, streaming agent output, indexing the monorepo or multi-repo workspace, RAG, retrieval quality, tool servers, sandbox setups (Docker, networking with core services).
- Improve natural-language-to-code workflows as an internal product: from task text to generated code, diff, and review.
- Keep the codebase maintainable: apply SOLID and clear boundaries where they help, refactor safely, and extend automated tests together with features.
Requirements
Must have
- Strong TypeScript and React in production.
- Node.js: server-side apps, REST and/or GraphQL, async programming.
- Databases: relational DBs + Prisma (or equivalent); basic MongoDB understanding.
- GraphQL: schemas, operations; Apollo (client and/or server), preferably subscriptions and WebSocket.
- Python for services: FastAPI, async, project structure, dependencies.
- SOLID principles and practical OOP / design patterns in TypeScript and Python (single responsibility, dependency direction, testable modules).
- Clean Code habits: clear naming, small focused units, readable control flow, sensible refactoring; ability to read and evolve existing code without unnecessary churn.
- Automated testing: writing and maintaining unit and integration tests in the stack you touch (for example Jest for Node/React, pytest for Python), and using tests to protect critical paths and refactors.
- Understanding of LLMs in production: prompts, tool calling, context limits, basic risks (hallucinations, secrets in generated code).
- RAG, vector search, knowledge graphs - solid basics and willingness to own this in our codebase; hands-on with a graph DB and vector DB is a strong plus.
- Docker and docker-compose: run stacks, debug services, understand container networking.
- Git, code review, careful changes across multiple codebases.
- English for documentation and code; comments in English.
Nice to have
- Major React UI kits, GraphQL Code Generator, Mongoose.
- MCP or similar tool protocols for LLM agents.
- Self-hosted inference (for example vLLM-class stacks), OpenAI-compatible endpoints.
- Experience with CLI coding agents or comparable automation.
- Client-side encryption (AES/RSA) or fast ramp-up from existing code.
- Fintech, back office, portfolio accounting, market data.
- TDD or a strong habit of adding tests with behavior changes, not only after the fact.
Soft skills
- Self-directed work across several repositories and a clear mental model of how they connect.
- Care with data and APIs around financial entities and encryption.
- Constructive review habits and clear trade-off communication.