⚙️ Founding Backend & AI Systems Engineer

About us

Kalmus Labs is building Remora, an AI-native learning platform designed to transform books, documents, and information into interactive, adaptive experiences people genuinely want to spend time with.

We’re combining AI, education, storytelling, design, personality, and technology to create something that feels less like traditional software and more like an environment for learning, thinking, and discovery.

We’re still a small team. That means the people joining now are not stepping into a finished machine, they will help shape the product, the company, and the way people first discover and understand Remora.

About the role

We’re looking for a backend engineer who can become one of the technical builders of Remora, not simply someone who waits for tickets and writes endpoints.

Remora already has a substantial working backend, a live demo, PostgreSQL persistence, document processing, AI/RAG systems, telemetry, user accounts, conversations, translations, highlights, and other infrastructure.

You will not be starting from an empty repository.

Your job will be to understand what already exists, improve it, challenge weak decisions when necessary, and help us build the next generation of the product on top of it.

We move quickly and use AI extensively in development. That means we do not need someone who treats AI-generated code as automatically correct, nor someone who refuses to use AI and spends days manually doing work that could take hours.

We need someone who can use AI as leverage while still being the engineer responsible for the result.

That means reading code critically, debugging difficult problems, reviewing architecture, catching bad assumptions, writing tests where they matter, and knowing when a quick solution is acceptable and when something needs to be designed properly.

Some days you’ll be designing a new backend system.

Some days you’ll be investigating why something that “should work” does not.

Some days you’ll be reviewing an AI-generated implementation, finding three hidden problems, fixing them, and shipping it.

We care about working systems, sound architecture, and speed of execution.

What you’ll do

• Take significant ownership of Remora’s backend architecture and implementation.
• Understand, maintain, and improve the existing Python backend rather than rebuilding everything unnecessarily.
• Build and maintain APIs, services, data models, persistence layers, and background workflows.
• Work with PostgreSQL, document storage, processing pipelines, and user/session data.
• Build and improve AI-powered systems involving LLMs, context construction, RAG, retrieval, routing, structured outputs, and model integrations. Help develop Remora’s Core Intelligence and future learning systems without turning LLM output directly into unverified product state. Review AI-generated and human-written code critically before it reaches production.
• Debug backend failures across application code, database behavior, third-party APIs, infrastructure, and AI systems.
• Improve reliability, error handling, observability, and performance.
• Work with telemetry and monitoring systems such as New Relic.
• Help maintain development, staging, and production environments.
• Work with Render deployments, environment configuration, secrets, databases, and related infrastructure.
• Design APIs and backend contracts that frontend and mobile developers can work against confidently.
• Think through migrations, compatibility, failure modes, and edge cases rather than only the happy path.
• Write tests where they meaningfully reduce risk and help prevent regressions.
• Review existing architecture and tell us when something should be simplified, redesigned, or left alone.
• Help establish backend engineering standards as the team and codebase grow.
• Use AI extensively for implementation, debugging, research, testing, refactoring, and code review while remaining accountable for the final system.
• Ship.

Our current backend includes

You do not need previous experience with every part of this stack, but you should be comfortable learning and working across systems like:

• Python
• FastAPI
• PostgreSQL
• REST APIs
• LLM APIs
• RAG / retrieval systems
• document ingestion and processing
• S3-compatible storage
• structured AI outputs
• authentication and user data
• Render
• New Relic / telemetry
• Git / GitHub
• third-party API integrations

The architecture will continue evolving as Remora grows.

You might be a good fit if you:

• think in systems rather than only individual functions or tickets;
• can enter an unfamiliar codebase and gradually form an accurate mental model of how it works;
• are strong at debugging and enjoy figuring out why something is actually broken;
• can distinguish a symptom from the underlying problem;
• are comfortable making architectural decisions and explaining the tradeoffs behind them;
• use AI aggressively to increase your output, but do not blindly trust what it generates;
• can review code for correctness, maintainability, security, and architectural consistency;
• are willing to rewrite AI-generated code when it is wrong instead of trying to defend it;
• prefer shipping a good solution quickly over spending weeks polishing something that does not require it;
• also understand when a shortcut would create serious technical debt later;
• can take ownership of a feature or system with limited supervision;
• ask questions when requirements are unclear rather than quietly inventing product behavior;
• can challenge technical or product decisions when you think something is wrong;
• communicate directly with frontend, product, design, QA, and the founder;
• are comfortable with an early-stage codebase where some parts are mature and others are still evolving;
• care about the product itself, not only the elegance of the code;
• can work independently and consistently deliver.

You do not need ten years of experience or a famous company on your resume.

We care much more about technical judgment, speed, ownership, debugging ability, architectural thinking, and what you can actually build.

Bonus points if you have experience with

• AI-native products;
• LLM applications;
• RAG systems;
• JEV
• embeddings / vector search;
• structured extraction from LLMs;
• agent or tool-calling architectures;
• model routing;
• prompt / context architecture;
• AI evaluation and observability;
• PostgreSQL schema design;
• async Python;
• FastAPI;
• cloud infrastructure;
• Render / AWS / similar platforms;
• object storage;
• document processing;
• queues / background jobs;
• event-driven systems;
• analytics / telemetry;
• CI/CD;
• performance optimization;
• security and authentication;
• designing systems that handle uncertain or probabilistic AI output;
• taking an early-stage product from prototype toward production.

Work style

• Remote.
• Approximately 15–20 hours per week at the current stage.
• Highly flexible schedule - work when it fits your life rather than following a fixed daily timetable.
• Designed to be compatible with university, another job, freelance work, or other commitments.
• We care much more about ownership, communication, reliability, and consistent output than about when during the day you work.
• Small, highly collaborative team.
• Direct communication with the founder and other engineers.
• Fast iteration.
• High technical ownership.
• Significant freedom in how you solve problems.
• Very little bureaucracy. * Because this role owns critical infrastructure, we do expect reasonable responsiveness when something you own is blocked or broken. That does not mean sitting online all day; it means communicating clearly and not disappearing when the team depends on you.

We are looking for someone who wants to gradually become a major technical contributor to the company, not someone looking for a short freelance project.

Compensation

Equity-first role - Pre-Seed stage

Target equity: ~3%

4-year vesting / 1-year cliff.

We want to be completely transparent: we do not currently have meaningful cash compensation available for this role, because this is a self-starting startup.

This is only a fit for someone who genuinely wants to help build a company from an early stage and is comfortable accepting real startup risk in exchange for meaningful ownership.

There are no guarantees in startups.

The goal, as Kalmus Labs grows, generates revenue, or raises funding, is to transition strong contributors into paid long-term positions as soon as possible.

We are not looking for someone who feels pressured to work for free. We are looking for someone for whom this particular risk/reward tradeoff genuinely makes sense alongside other work/school/personal commitments.

For the right person, this role can grow into significant technical ownership as the company expands.

How to apply

📩 Send us:

• GitHub;
• LinkedIn / resume / relevant profile;
• anything meaningful you’ve built;
• examples of backend, AI, infrastructure, open-source, startup, or personal projects;
• and a few honest sentences answering:

You inherit an existing AI startup backend that was built quickly by several developers using AI-assisted coding. Some systems are solid, some are poorly documented, and some may contain architectural or reliability problems. What would you do during your first week?

Send to: [email protected]

Please avoid AI-generated essays or generic corporate applications.

Using AI is not only fine - we expect strong candidates to know how to use it.

But we want to see your technical judgment. One clear paragraph showing how you think is worth far more to us than five pages of AI-written engineering language.

🌐 kalmuslabs.com (soon to be updated)