Wanted: Senior Backend Alchemist @ topmate.io 🧙‍♂️⚡🐍

sudo apt-get install senior-backend-dev --with-ai-superpowers

About Topmate.io

Topmate.io is the operating system of the creator economy. We power 1:1 sessions, webinars, digital products, cohorts, and everything in between for hundreds of thousands of creators and experts worldwide. Behind the clean UX is a lot of hard, interesting backend work — high-throughput APIs, event-driven pipelines, payment/accounting correctness, and an increasingly AI-native engineering culture that turns good engineers into 10x operators.

We're not looking for a code monkey. We're looking for someone who reads stack traces for breakfast, treats EXPLAIN ANALYZE like poetry, and has already replaced half their IDE muscle memory with Claude Code shortcuts.

TL;DR

Role: Senior Backend Developer
Experience: 4+ years of production backend work, ideally with a scar or two from a 2 AM queue meltdown
Compensation: As per industry standards — fair market rate for senior ICs
Location: Bengaluru, in-office. Our whiteboards are load-bearing infrastructure.

What You'll Actually Do

Architect and scale the systems that move the creator economy — APIs, async pipelines, webhooks, state machines, the works.
Design services when monoliths are the wrong hammer, and keep the monolith sharp when it's the right one.
Wrestle with real distributed-systems problems: race conditions in double-entry ledgers, webhook idempotency, payment reconciliation, commission math that has to survive audits.
Own services end-to-end in production — write it, deploy it, observe it, page yourself when it breaks, fix the root cause, not the symptom.
Live inside dashboards. If you can't correlate a p99 spike to a slow query in under 10 minutes, this isn't your role yet.
Build AI-native features — agentic workflows, RAG pipelines, LLM-powered search/recommendations, function-calling tools wired into real business logic. We already ship a few; you'll ship many more.
Relentlessly refactor. Delete more code than you add. Treat abstractions as debt until proven otherwise.
Review PRs like a kernel maintainer — kind, direct, technical, allergic to hand-waving.

The Non-Negotiable Skill: AI-Native Development

This is 2026. We don't hire engineers who type every line by hand. We hire engineers who orchestrate code.

You should already be deeply fluent with:

Claude Code — skills, subagents, hooks, MCP servers, custom slash commands, settings.json sorcery. You know when to spawn a subagent vs inline the work.
Cursor / Windsurf / Codex / Aider — you've tried them all and have strong opinions.
LangGraph for stateful agent orchestration — you've built a multi-step agent that survived contact with production traffic.
Langfuse (or equivalent) for tracing, evals, and prompt versioning. If you've ever shipped an LLM feature without observability, we need to talk.
MCP (Model Context Protocol) — bonus if you've written your own server.
Prompt engineering as an actual engineering discipline — not "vibes-based prompting." You write eval suites. You version prompts. You measure hallucination rates.
Context engineering — you know how to feed a model exactly what it needs and nothing it doesn't. Cache hits matter. Token budgets matter.
Comfort with the full modern LLM toolbox: embeddings, vector search, function calling, structured outputs, streaming, fine-tuning when it's actually worth it.

If your PR velocity hasn't at least 3x'd in the last year thanks to AI tooling, you're either not using them right or not using them at all. Both are fixable, but we'd prefer you arrive already fluent.

You'll Thrive Here If You

Read source code faster than documentation (because docs lie, code doesn't)
Have opinions about asyncio vs threading vs multiprocessing and can defend them
Have debugged a deadlock by reading lock tables at 2 AM
Understand why SELECT COUNT(*) on a massive table is a bad idea and what to do instead
Think "it works on my machine" is a confession, not a defense
Have strong feelings about tabs vs spaces and don't bring them into code reviews
Get the reference when someone says "there are only two hard things in Computer Science"
Have a GitHub graph that looks like a terminal screensaver
Contribute to OSS, write technical blog posts, or maintain a homelab running more services than some startups

You'll Hate It Here If You

Need Jira tickets spelled out in crayon before starting work
Think "senior" means "writes less code and more PowerPoints"
Get defensive in code reviews
Have never killed your own print statement in production
Think AI tools are "just a fad"

The Interview Gauntlet

Intro call — vibes + background check. 30 min.
Technical deep-dive — we walk through one of your past systems. Expect "why not X?" for every decision.
Paired debugging session — a real bug in a real repo. You + us + your AI tooling of choice. We're evaluating how you think, not whether you memorized LeetCode.
System design — scale a real problem. You pick the angle.
Founder chat — culture, trajectory, what the next 2 years look like for you here.

Perks (the ones that actually matter to engineers)

Unlimited Claude Code access — use it as much as you want, no quota anxiety
Unlimited LLM tokens — Anthropic, OpenAI, whichever model fits the task. Go play. Go build.
Lunch and dinner on us — fuel the compiler, fuel the human
Learning budget — conferences, books, courses, LLM/GPU credits for side experiments
Unlimited leaves, taken seriously
Offsites, team dinners, and the occasional karaoke catastrophe
Founders who code-review your PRs and argue about database isolation levels over coffee

How to Apply

Fill the form here: https://app.youform.com/forms/s02piald

Tell us:

Your GitHub / portfolio link
A short write-up (≤500 words) on the gnarliest backend bug you've shipped a fix for — include the root cause, not just the patch
One AI-native workflow you've built for yourself (Claude Code skill, Cursor rule, custom MCP server, LangGraph agent, anything) — show us your setup
Your coolest pet project

Bonus points if your cover letter is generated by an agent you built — and you tell us which agent, which model, and what the system prompt looked like.

P.S. — If you read this whole JD and your first thought was "I wonder how they handle distributed transactions across sync and async workers," we should probably already be talking.

# EOF
if you.read_this_far and you.are_excited:
    apply()
else:
    # no hard feelings, the JD self-selects
    pass

dinesh1301/django-dev.md

Select an option

No results found