Who are we

Prismforce is a Vertical SaaS company revolutionizing the Talent Supply Chain for global Technology, R&D/Engineering, and IT Services companies. Our AI-powered product suite enhances business performance by enabling operational flexibility, accelerating decision-making, and boosting profitability. Our mission is to become the leading industry cloud/SaaS platform for tech services and talent organizations worldwide.

Job Title: SSDE 1 - Backend Node

Experience: 4-7 Years

Location: Bangalore/Pune

Employment Type: Full-time

Job Description: SSDE 1 - Backend

Employment Type: Full-time

Job Description

Senior Software Development Engineer

Backend Platform

Python / FastAPI
58 Years

Level: Senior IC (SSDE / SDE-II) Stack: Python Type: Full-Time Mode: Remote / Hybrid

About The Role

We are building an agentic, AI-powered interview and assessment platform one that conducts intelligent domain-aware interviews, generates role-calibrated questions in real time, and evaluates candidates through LLM-driven pipelines. The backend is the platform.

As a Senior SDE on the backend team, you will own the design, development, and productionisation of core Python services from first prototype to hardened, distributed systems running at scale. You will spend real time researching emerging approaches, prototyping agentic workflows, and refactoring early-stage code into clean, observable, production-grade systems.

This is not a maintenance role. We expect curiosity, rigour, and end-to-end ownership.

What We're Looking For Priority Order

Candidates are evaluated in this order. Depth in #1 and #2 is non-negotiable. Weakness in #4 or #5 is acceptable if you're exceptional elsewhere.

Priority

Skill Area

Expectation

Must Have

CS Fundamentals & Systems

Memory model, concurrency, runtime internals, CPU/memory profiling, complexity. Hard filter.

Must Have

Database Design

SQL + NoSQL fluency, multi-tenant patterns, schema design, indexing, query optimisation. Hard filter.

Working Knowledge

Distributed Systems & Event-Driven

Practical experience with queues/events, failure modes, resilience patterns. Gaps are discussable.

Working Knowledge

Testing & Observability

Solid test discipline, structured logging, production metrics/tracing. Learnable must show intent.

Good to Have

Agentic AI / LLM Integration

Not a decider. Strong engineers without this will not be screened out.

What You'll Do

Design and build high-performance backend services clean API contracts, async architecture, lifecycle management.

Own the full backend lifecycle: research ? prototype ? design review ? build ? test ? deploy ? monitor.

Architect event-driven pipelines for real-time transcript processing, candidate signal extraction, and question generation.

Drive database design decisions schema evolution, indexing strategy, multi-tenant isolation, and query optimisation.

Diagnose and fix memory leaks, CPU bottlenecks, and resource exhaustion in long-running services.

Set and enforce engineering standards: testing, linting, structured logging, distributed tracing, build tooling.

Evaluate and integrate LLM/agentic components with proper retries, fallbacks, and observability.

Write design docs, contribute to architectural RFCs, and lead code reviews with context.

Run POCs on emerging AI evaluation frameworks and translate findings into production systems.

Mentor junior engineers on both craft and product thinking.

Python Ecosystem

FastAPI with async/await, Pydantic v2, dependency injection, middleware, WebSocket handling.

uv for dependency management, virtual environments, and reproducible builds. pyproject.toml, wheel packaging.

pytest, pytest-asyncio, httpx TestClient fixture design, mocking strategies, coverage thresholds.

structlog or equivalent for structured logging; ruff + mypy + pre-commit for linting and static analysis.

Profiling tools: py-spy, cProfile, tracemalloc, objgraph used in production, not just tutorials.

Deep knowledge of the Python runtime: GIL, memory model, garbage collection, reference counting.

CS Fundamentals & Systems ? Bar-Raising

This is the primary filter. We will go deep here in every interview round.

We are not looking for someone who knows these topics we are looking for someone who has felt the pain in production and solved it.

Data structures and algorithms not LeetCode grinding, but genuine comfort with complexity analysis and making the right choice in a design.

Concurrency in depth: threading vs async, race conditions, deadlocks, thread-safety in shared state, lock-free patterns.

Python runtime-specific: GIL contention, CPython memory model, asyncio event loop, multiprocessing vs threading tradeoffs.

Memory and CPU profiling hands-on diagnosis of leaks and regressions in production services, not just theory.

SOLID, DRY, abstraction, encapsulation and knowing when to deliberately break them. Pragmatism over dogma.

OS-level awareness: file descriptors, signals, resource limits, socket behaviour, process isolation.

Database Design ? Bar-Raising

This is the second primary filter. Theoretical knowledge is not enough.

We expect you to make database design decisions and defend them not just use an ORM.

Relational databases: normalisation, joins, indexing strategies (B-tree, composite, partial), ACID guarantees, query planning, execution plans.

MongoDB: schema design, aggregation pipelines, compound and TTL indexes, connection pool tuning, transactions where needed.

SQL vs NoSQL tradeoffs: can reason contextually, not ideologically. Knows when a document store is the wrong choice.

Multi-tenant database architecture: silo vs pool vs bridge models, tenant isolation, row-level security, data partitioning.

Caching layers (Redis), read replicas, eventual consistency and when each is appropriate.

Schema evolution strategies: migrations, backward compatibility, zero-downtime deployments.

Distributed Systems & Event-Driven Architecture

Practical experience designing distributed systems service decomposition, REST vs gRPC vs async messaging.

Hands-on with Kafka or RabbitMQ consumer groups, offset management, at-least-once delivery, idempotency, dead-letter queues.

CAP theorem, eventual consistency, saga pattern, outbox pattern for distributed transactions.

Resilience patterns: circuit breakers, bulkheads, retries with backoff, graceful degradation.

API gateways, rate limiting, service mesh basics.

Testing & Observability

Solid unit and integration testing discipline well-structured fixtures, meaningful coverage, not just chasing percentages.

Structured logging: correlation IDs, log levels, aggregation. Knows the difference between a log and a metric.

Observability: Prometheus, Grafana, OpenTelemetry, distributed tracing (Jaeger or equivalent).

Meaningful SLIs and SLOs. Has been on-call. Has written a postmortem worth reading.

CI/CD pipelines, containerised deployments (Docker, Kubernetes), infrastructure-as-code awareness.

Agentic AI Good to Have, Not a Decider

This will not make or break your candidacy. Strong engineers without this background will not be screened out. If you have it, it counts. If you do not, we expect the willingness to learn fast in a research-forward environment.

Experience building LLM-based agentic workflows tool use, ReAct loops, multi-agent coordination, memory and context management.

Familiarity with LangChain, LangGraph, LlamaIndex, or similar. Not framework-loyal understands primitives.

Prompt engineering, RAG pipelines, embedding models, evaluation harnesses (RAGAS, LLM-as-judge, custom evals).

Research appetite: can read a paper and have a working prototype shortly after.

The Kind of Engineer We're Looking For

You approach ambiguous problems with curiosity, not anxiety. First-principles thinking is your default.

You know when to prototype fast and when to slow down and design. You can tell the difference.

You write code for the next engineer, not just the next sprint.

You champion the right solution not your solution.

You stay current with the AI/ML ecosystem because you are genuinely fascinated, not because you were told to.

You have worked in a high-velocity environment and thrived on the ownership it brings.

Nice to Have

Speech/NLP pipeline experience: ASR (Whisper, Deepgram), diarisation, transcript normalisation.

Vector databases: Qdrant, Weaviate, or Pinecone semantic search, embedding pipelines.

ML model serving: ONNX, vLLM, TorchServe, or custom inference APIs.

Prior work in HR tech, edtech, or assessment platforms.

Open-source contributions or published technical writing.

Frontend Full Stack Developer (React & Node.js) Job

SSDE -1 Python Fast API

UI Specialist - React Job

Frontend Engineer - React

Sr. React JS Developer

Senior Software Engineer (React JS)

System Analyst -.NET, Node & React/Vue/Angular(4-8 yrs)