Talana Labs builds products that people use every day, so the internet works the way it should. We have several products: some are connected into a shared network, others grow on their own.
You'll join the product team of one of our business lines. The product lives in Telegram: a Mini App plus a bot. Users pick a service, pay for it from their in-app balance, get the result, and manage it right inside the Mini App. Things move fast: the backlog holds new features and codebase improvement tasks side by side.
You'll work under a team lead, who sets priorities, runs reviews, and helps when things get tricky. Once the high-level tasks are set, breaking them down, defending your solution, implementing it, and taking it to production are on you. We need someone who can independently drive a feature from the DB schema and migration all the way to a working screen in the Mini App, inside an existing codebase.
AI (Cursor, Claude, or anything else) is a normal everyday tool for us, and we expect you to use it. But you don't outsource architecture to AI models: you check the diffs before sending them to review, you don't bypass existing abstractions, and you don't commit anything you don't understand yourself. In review, you defend the solution yourself instead of pointing at the AI.
What you'll be doing
Owning features end to end: from the DB schema and migration to a screen in the Mini App, within the existing codebase.
Building new user-facing and admin features.
Improving the codebase: refactoring, aligning abstractions, getting rid of old hacks.
Fixing bugs, including those at the intersection of payments, the external provider, frontend, and backend.
Profiling bottlenecks: queries, renders, queues, data sync with the provider.
Writing tests (unit, integration, and load tests when needed) as a mandatory part of working on a feature.
What we expect
Level
Senior. We are not considering Middle, Junior, or Intern candidates for this position.
TypeScript
Strong command of TypeScript: generics, discriminated unions, type narrowing, working in strict mode without bypassing the type system with as any.
The ability to read and build on someone else's modular code, rather than rewriting a layer your way in your very first PR.
Git: meaningful commits, clear PRs, the ability to resolve conflicts in a monorepo.
Backend
NestJS: modules, DI, guards, pipes, interceptors, background processors.
Hands-on PostgreSQL: transactions, unique constraints, indexes where they make sense, entity statuses, idempotent webhooks, and an understanding of what happens when an event is delivered twice.
Query builder / SQL: readiness to work with a query builder without an ORM.
Integrations with external HTTP APIs: signatures / HMAC, pagination, mapping an external model to an internal one, timeouts, and error handling.
Queues (BullMQ + Redis) and an understanding of what you must not do synchronously inside an HTTP request.
Frontend
React: hooks, context, stores.
Routing (React Router), server state (TanStack Query).
Vite, Tailwind + shadcn/ui, clean layouts for a mobile WebView.
UI logic testing (Testing Library / Vitest or similar), and readiness to set up a testing pipeline if there isn't one yet.
An understanding of the Telegram ecosystem as a product channel: Mini App and bot.
What matters to us in how you work
Communicate constructively: if you disagree with something, you come to the team lead with arguments instead of quietly breaking conventions.
Maintain quality: types, clear PRs, tests for risky areas, no dead code.
Make decisions with incomplete specs, without putting a task off for a week for analysis or waiting for a perfect specification.
Tell a one-hour solution from a multi-day one.
Escalate blockers on your own: unclear product requirements, gaps in the domain model, financial risks, doubts about the guidelines.
Write short and to the point: context, options, a recommendation, what's already done.
Don't go dark on a task. Its status should be clear without follow-up questions.
Defend your technical decisions in review: answer questions and ask your own.
Close a task completely, both frontend and backend, when needed.
Who we're not looking for
A frontend-only or backend-only developer who isn't ready to cover the adjacent layer within the same task.
Someone who needs every task laid out step by step.
Someone who spends months designing services but never gets features to merge.
A developer who starts every change by introducing a new framework, ORM, or state manager.
People who ignore the guidelines, don't discuss decisions with the team lead, and can't defend them.
An executor who mindlessly pastes AI-generated code without understanding how it works.
Those who consider tests, Docker, and working with Kubernetes manifests to be someone else's job.
How we work
Stack: Nx + pnpm monorepo, TypeScript strict, Node.js / NestJS, React + React Router + Telegraf + TanStack, PostgreSQL, Docker, Kubernetes (you won't have to set it up yourself, we have DevOps, but sometimes you'll need to find your way around the infrastructure).
Mode: remote work, asynchronous collaboration with clear task statuses. Regular contact with the team lead, and questions get resolved as you go.
Language: Russian (we'll also consider candidates with good English). The product interface is RU / EN.
The stack and domain are already set: you grow them, you don't choose them from scratch.
No zoo of microservices: a few separate processes with a shared domain model and shared packages.
We have development guidelines (architecture, style, module boundaries, working with AI, Git). You need to read and follow them. If a guideline gets in the way of solving a task, that's a reason to discuss it with the team lead, not to quietly work around it.
What we offer
A market-level salary, reviewed after each Performance Review.
A team of strong engineers united by the idea of building digital products.
Remote work, full-time with a flexible schedule.
Reimbursement of learning expenses.