Sr. Backend Engineer – GenAI

Technical Expertise

• Proficiency in Node.js or Python – Hands-on experience with backend development frameworks

and best practices.

• Expertise in SQL/NoSQL Databases – Strong experience with MySQL, PostgreSQL, MongoDB, or

DynamoDB.

• ElasticSearch & API Development – Strong knowledge of REST APIs, ElasticSearch, and high-

availability system design.

• Cloud & DevOps – Hands-on experience with AWS, Kubernetes, Docker, and CI/CD pipelines.

• Data Structures & Algorithms – Strong command over data structures, algorithms, OOD, and

design patterns.

• Version Control & Deployment – Experience with Git, GitHub Actions, and other deployment

systems.

• High-Performance Systems – Implemented solutions that handle high availability, concurrency,

and low-latency requirements.

About the Role

Unico Connect is an AI-first technology partner that builds custom mobile, web, and AI products for clients across multiple geographies. We are hiring a Backend Engineer for a dedicated client engagement building an AI-powered application builder platform.

The backend is the operational core of the product: it manages user projects and sessions, coordinates long-running AI agent workloads, maintains project state, and serves as the integration layer between the frontend, the AI system, and the underlying infrastructure.

The mandatory requirement is hands-on production experience shipping Node.js services, with end-to-end ownership of API design, data modelling, and at least one production system involving background job processing or event-driven patterns.

Responsibilities

API and service development: Design and build REST APIs in Node.js with TypeScript. Cover authentication, session management, input validation, structured error handling, streaming responses (SSE, WebSockets), and rate limiting. Maintain clean API contracts that the frontend and AI system can rely on.

Database design and management: Own PostgreSQL schema design for product domains including user accounts, projects, file trees, session state, and generated artefacts. Write efficient queries, manage migrations, and optimise for read patterns that serve a real-time editor experience.

Caching strategy: Implement and maintain caching with Redis for session data, project state, and frequently read configuration. Design cache invalidation logic that keeps the editor experience consistent without stale reads.

Queue and background job management: Implement and operate background job infrastructure using BullMQ or equivalent. AI agent runs are long-running and stateful; handle retries, failure states, priority queues, and concurrency limits.

AI system integration: Build the integration layer between the backend and the AI agent system. Manage job dispatch, result handling, streaming output to the frontend, and error propagation.

Multi-tenancy and access control: Implement tenant data isolation, RBAC, and resource ownership enforcement across all API surfaces.

Observability and reliability: Instrument services with structured logging, metrics, and tracing. Write defensive code with sensible timeouts, fallback behaviour, and circuit breaking on external dependencies.

Testing and code quality: Write unit and integration tests for the services you ship. Review the work of peers and contribute to shared engineering conventions.

Requirements

• Hands-on production Node.js experience (mandatory) — must have personally shipped at least one feature area end to end in a production Node.js service, owning API design, data modelling, and testing.

• 3 to 5 years of professional backend engineering experience. Candidates with slightly less time but strong demonstrated ownership are welcome to apply.

• Strong Node.js and TypeScript. Production experience with Express, NestJS, or Fastify. Solid with async patterns, streaming, error handling, and building services that run reliably under sustained load.

• PostgreSQL depth. Schema design, query writing, indexing, and migrations on at least one production system.

• Redis and caching. Production experience using Redis for caching and session management. Understands cache invalidation trade-offs.

• Queue and background job systems. Hands-on with BullMQ, RabbitMQ, SQS, or equivalent. Experience managing retries, dead-letter queues, job priority, and concurrency control.

• AWS working knowledge. Comfortable with EC2, S3, RDS, SQS, and IAM. Familiar with Docker and basic deployment and environment management.

• Strong written and spoken English. Able to communicate clearly with engineers across disciplines and write precise technical documentation.

Nice to Have

Experience integrating with AI or LLM services (streaming responses, structured outputs, retry patterns); WebSocket or SSE implementation for real-time features; multi-tenant SaaS product experience; GraphQL; OpenTelemetry instrumentation; prior work on developer tools or editor-style products.

Role overview

The client is building a multimodal AI platform that processes multi-hour video, audio and text to generate structured insights, narratives and highlight workflows for broadcasters and media organisations.

We are seeking a Backend / Platform Engineer to design and build high-throughput media pipelines, robust APIs, and model-serving infrastructure that connect our AI engine (video perception + multimodal reasoning) to real products and customer environments.

This is not a CRUD‑only backend role.

You will work on:

• long‑running jobs
• distributed processing
• GPU inference orchestration
• storage for embeddings and metadata
• integration with AI models
• reliability and observability at scale

Key responsibilities

Media ingestion & processing pipelines

• Design and implement ingestion pipelines for multi‑hour video and audio content.
• Build microservices for frame extraction, audio processing, transcription integration and metadata generation.
• Handle long‑running, asynchronous jobs using queues, workers and robust retry strategies.
• Integrate with FFmpeg or similar tools for transcoding, segmenting and preparing media for AI models.

API & platform architecture

• Design and implement REST/gRPC APIs that expose AI model outputs (perception, multimodal alignment, narratives) to frontend and external systems.
• Define clear contracts for internal services and external integrations.
• Implement authentication, authorisation and rate‑limiting for platform endpoints.
• Ensure backward‑compatible API evolution as the product matures.

Model‑serving & AI integration

• Integrate with AI inference services (video models, multimodal models, LLM/VLM) running on GPUs or specialised infrastructure.
• Design request/response flows that handle large payloads, streaming outputs and structured results.
• Optimise throughput and latency for inference pipelines, including batching, caching and concurrency control.
• Collaborate closely with AI engineers to productionise models and debug end‑to‑end behaviour.

Storage, data models & performance

• Design data models to store embeddings, timelines, metadata, scene/shot boundaries, and narrative units.
• Work with appropriate storage technologies (SQL/NoSQL, object storage, search indices) based on access patterns.
• Implement indexing and query strategies for fast retrieval of segments, highlights and multimodal insights.
• Optimise performance for large datasets and high‑volume workloads.

Reliability, observability & operations

• Implement logging, metrics and tracing across services for debugging and monitoring.
• Set up health checks, circuit breakers and graceful degradation for critical services.
• Work with CI/CD pipelines to ensure safe, repeatable deployments.
• Collaborate on Kubernetes‑based deployments (or equivalent orchestration) for scaling services.

Requirements (must‑have)

Experience:

• 4–8 years in backend or platform engineering.
• At least 3 years working on distributed systems, high‑throughput services or complex pipelines (not just simple CRUD apps).

Languages & frameworks:

• Strong proficiency in Python or Node.js (one primary, both are a plus).
• Experience with at least one modern backend framework (FastAPI, Flask, Express, NestJS, etc.).

Distributed systems & pipelines:

• Hands‑on experience with queues and workers (e.g. Celery, RabbitMQ, Kafka, SQS, etc.).
• Experience building asynchronous, long‑running job pipelines.
• Understanding of idempotency, retries, backoff, and failure handling.

APIs & integration:

• Strong experience designing and implementing REST APIs (gRPC is a plus).
• Experience integrating with external services and handling network‑level failures.

Cloud & infrastructure:

• Experience deploying services on AWS, GCP or Azure (EC2/Compute Engine, S3/GCS, IAM, networking basics).
• Experience with Docker; exposure to Kubernetes is a strong plus.

Data & storage:

• Experience with SQL and at least one NoSQL store.
• Ability to design schemas and data models for performance and maintainability.

Engineering quality:

• Strong debugging skills across services and environments.
• Experience with unit/integration tests for backend systems.
• Clear, structured communication in English.

Nice‑to‑have

• Experience with media/video processing (FFmpeg, transcoding, segmenting).
• Experience with AI/ML model integration (serving models, handling inference requests).
• Experience with search/retrieval systems (e.g. Elasticsearch, vector databases).
• Experience with observability stacks (Prometheus, Grafana, OpenTelemetry).
• Experience working with remote teams across time zones.

What we are explicitly NOT looking for

To reduce noise and mismatches, we are not looking for:

• Pure CRUD‑only backend developers with no pipeline or distributed systems experience.
• Engineers who have only worked on small, single‑service apps without scale or complexity.
• Candidates who cannot explain trade‑offs in architecture, data modelling and reliability.
• Candidates who are uncomfortable with ownership of subsystems end‑to‑end.

Why join us

• Work on real, complex problems at the intersection of media, AI and distributed systems.
• Collaborate with senior AI engineers working on perception, multimodal fusion and narrative reasoning.
• Build the core platform that turns AI models into a usable product for broadcasters and media organisations.
• Operate with high ownership, clear expectations and direct access to the CTO.

Strong Backend Node.js Developer Profile

2

Mandatory (Experience 1) – Must have 7+ years of hands-on Backend Engineering experience using Node.js building production-grade systems for B2C products at meaningful consumer scale

3

Mandatory (Experience 2) – Must be AI-native in their own engineering workflow: already uses LLMs and agentic tooling across the SDLC, from design and code generation through testing and debugging

4

Mandatory (Experience 3) – Must have owned backend architecture end to end, including greenfield builds. Should be able to make early architecture calls and reason clearly about service boundaries, data flow, caching, queueing, failure modes, scalability, and reliability trade-offs under real constraints.

5

Mandatory (Experience 4) – Must have a solid understanding of backend fundamentals, including API development, service-oriented architecture, data structures, algorithms, and clean coding practices

6

Mandatory (Experience 5) – Must have experience designing, building, and maintaining APIs and backend services, including integrations with external systems and third-party platforms

7

Mandatory (Experience 6) – Must have strong experience working with databases (SQL and/or NoSQL), including efficient data modeling, query optimization, and performance tuning

8

Mandatory (Company) – Must have worked in B2C product companies / startups at meaningful consumer scale. (WealthTech, FinTech, or high-growth consumer product background is highly preferred)

9

Mandatory (Stability) – Must have a stable career history, with consistent tenure across previous companies; frequent job-hopping will not be considered

10

Mandatory (AI Product) – Must have experience building and shipping products that use LLMs and agentic workflows to end users.

11

Mandatory (College) – ) - B.Tech or Dual degree (Btech and Mtech or Integrated Msc/MS) from Tier 1 Engineering Institutes (IITs, not NITs). Candidates from other institutions will not be considered unless they come from top top-tier product companies

12

Mandatory (Compensation Alignment) – Candidate must be comfortable with the compensation structure where the company matches their current CTC and provides ESOPs, without any salary hike

Backend Developers

• Contract To Hire (Initial Engagement: 6 months)

Experience: 5+ years

Mandatory Skills:

● Node.js

● Python

● MongoDB

● PostgreSQL

● REST API design and development

● Backend architecture and service design

● Database design, indexing and query optimisation

● Performance tuning

● Authentication/authorisation

● Third-party integrations

● Asynchronous processing and background jobs

● Logging, monitoring and debugging

● Git and collaborative development

● Scalable, maintainable and testable backend services

● Architecture discussions, code reviews, debugging and production support

Good to have:

● Microservices

● Docker

● Cloud platforms

● Redis

● Message queues

● CI/CD

● Observability

About VerbaFlo.ai

VerbaFlo.ai is a fast-growing AI SaaS startup revolutionizing how businesses leverage AI-powered solutions. As a part of our dynamic team, you’ll work alongside industry leaders and visionaries to drive innovation and execution across multiple functions.

Role Overview

We are looking for a Senior Backend Engineer to design and develop user-friendly, scalable, and high-performance web applications. This role requires deep expertise in backend technologies, attention to detail, and the ability to collaborate with cross-functional teams.

Responsibilities

• Design, develop, and maintain scalable backend systems, APIs, and data pipelines.
• Collaborate closely with frontend engineers, product managers, and AI teams to deliver cohesive features and seamless user experiences.
• Ensure the reliability, security, and performance of backend systems.
• Write clean, maintainable, and efficient code using modern backend practices.
• Implement automated testing, CI/CD workflows, and infrastructure as code (where applicable).
• Own the end-to-end lifecycle of backend features, from architecture to deployment.
• Monitor production systems and resolve performance and scalability issues.
• Contribute to architectural decisions and help evolve our engineering best practices.

Requirements

• 4–6 years of experience in backend development in startups, preferably in SaaS or AI-driven products.
• Proficiency in Node.js, Python, or Go
• Deep understanding of RESTful API design.
• Strong experience with databases: PostgreSQL, MongoDB, ElasticSearch.
• Exposure to message queues, job schedulers, or event-driven architectures (e.g., SQS, Celery, etc).
• Familiarity with cloud platforms like AWS, GCP, or Azure and containerization tools (Docker, Kubernetes).
• Experience with Git, CI/CD tools, and writing unit/integration tests.
• Strong problem-solving skills and a mindset geared toward performance and security.
• Excellent communication and collaboration abilities.

Why Join Us?

• Work directly with top leadership in a high-impact role.
• Be part of an innovative and fast-growing AI startup.
• Opportunity to take ownership of key projects and drive efficiency.
• A collaborative, ambitious, and fast-paced work environment.
• Perks & Benefits: gym membership benefit, workation policy, and company-sponsored lunch.

If you’re looking for an exciting role that combines strategy, execution, and leadership exposure, we’d love to hear from you!

Why This Role Matters

Our backend is what keeps checkout, RTO, and payments fast and reliable at ~$2B GMV across 15,000+ merchants. As an SDE 2 you own services end to end, make the architecture calls that keep them performant, and set the technical bar for the engineers around you. The trade-offs you pick show up directly in merchant conversions and platform reliability - this is a builder's seat with real ownership.

What You'll Own

• Design and build backend services primarily in Node.js/NestJS, with Go for select services, backed by Postgres, Mongo, and Redis.
• Own event-driven flows on Kafka - throughput, ordering, and failure handling.
• Make and document the architecture and trade-off decisions for systems you lead.
• Ship features end to end, dropping into the frontend (React/Svelte) when it's the fastest path.
• Strengthen CI/CD, observability, and deployments on AWS.
• Review code, mentor SDE 1s and AEs, and raise the quality bar on the team.
• Take ambiguous problems and drive them to delivery with minimal hand-holding.

Who You Are

• Strong backend engineer in JavaScript/TypeScript on Node.js/NestJS (our primary stack); working knowledge of Go, or ready to pick it up.
• Solid at data modelling across Postgres and Mongo, and knows when Redis earns its place.
• Has built and scaled event-driven systems (Kafka or equivalent).
• At home on the backend but happy to work across the stack in React/Svelte.
• Thinks in systems - scalability, reliability, maintainability - not just features.
• Has mentored engineers and owns code quality and delivery, not just their own tickets.
• Communicates clearly and does well with ambiguity in a fast-moving team.

Experience: 8+ years, senior candidates only | Type: Full-time | Location: Remote (India)

 ---

 WHAT WE'RE BUILDING

 See http://www.juliet.space

 We're building Juliet, an AI that runs marketing end to end. Our users are marketers, founders, CEOs, growth leads, agencies, and SMBs — not developers. They

 tell Juliet the goal. She plans, writes production code, and ships real marketing: conversion-optimized websites, launch assets, campaigns, audits, autonomously.

 That's the engineering problem in one line: the humans in the loop can't read code, so the agent has to get it right on her own — plan, build, self-correct,

 recover, ship.

 Under the hood: a browser-based studio backed by cloud sandboxes, a real-time SSE streaming pipeline, and a LangGraph agent working across 83 tools and 63 skill

 modules. The agent isn't bolted onto the product. She is the product.

 Small team, big ambitions. You'll ship things users touch daily, not write tickets about them.

 ---

 THE ROLE

 We're hiring one architect-level backend engineer to own Juliet's agentic infrastructure end to end. That means the agent graph, the execution environment, the

 streaming pipeline, the state and memory systems — and setting technical direction for the engineers working alongside you.

 This is a player-coach seat. You'll still write code every day, and your architectural calls become the product. You'll work directly with the founder. No PMs in

 between.

 Frontend is part of the system. You won't be leading it, but you'll need to understand how the agent's output reaches the browser and be able to ship full-stack

 features when needed.

 ---

 THE STACK

 AI agent (primary): Python 3.11, LangGraph 1.x + LangChain, Anthropic / Google / OpenAI model providers

 API (primary): NestJS 11, Supabase, Redis, PostgreSQL, Server-Sent Events

 Infra (primary): Modal cloud sandboxes, Docker, Netlify deployments

 Frontend (secondary): Next.js 15, React 19, TypeScript, Zustand, CodeMirror 6, XTerm.js

 Monorepo: Turborepo, pnpm

 ---

 WHAT YOU'LL WORK ON

 The majority of your time is here:

 Agentic AI workflows — Design, extend, and harden the LangGraph agent graph: multi-step planning, code generation, tool dispatch, self-correction, and recovery

 across 83 tools and 63 skill modules. This is the core of the product.

 Real-time streaming architecture — The SSE pipeline that carries every agent action from the Python backend through NestJS to the browser: event framing,

 reconnection, health monitoring, interrupt handling for plan approvals and clarifying questions.

 Agent execution environments — Sandbox lifecycle on Modal: container spin-up, file sync, terminal I/O, command execution, and live preview with per-asset esbuild

 bundling. The agent lives here.

 State and memory systems — LangGraph Postgres checkpointers, middleware-injected context (goals, design docs, memory anchors), conversation summarization. How

 the agent knows what it knows.

 Backend API and data layer — NestJS services, Supabase schema, Redis caching, quota enforcement, webhook handling. The plumbing the agent depends on.

 Marketing intelligence pipelines — AEO, CRO, and brand-perception audit engines: multi-LLM probing, parallel inference, streamed structured reports, result

 caching. Audit-at-scale infrastructure.

 The remaining ~25% of your time:

 Full-stack product features — Collaboration (roles and permissions), the Netlify deployment pipeline, subscription and quota flows, onboarding. You'll ship these

 end to end — backend first, frontend to close the loop.

 ---

 WHAT WE'RE LOOKING FOR

 Must-have:

 - 8+ years of professional software engineering, including meaningful time as a tech lead or systems architect who owned something end to end. Closer to ten is

 the norm for people who thrive here.

 - Both worlds on your resume: engineering rigor inside a large company and 0-to-1 ownership at an early-stage startup.

 - Production agentic systems experience. You've built and operated LLM agent systems in production with LangGraph, LangChain, or equivalent — agent graphs, tool

 use, state management, prompt engineering, evals. This means well beyond calling a chat endpoint.

 - Strong Python. You design and ship production Python daily. The agent codebase is yours to own.

 - Architect-level system design. You can own how data flows across four services, make tradeoffs under uncertainty, and defend every call.

 - AI-native development workflow. You drive Claude Code, Codex, or similar agentic tools as everyday instruments — not occasionally. You have opinions about

 working with coding agents because you do it constantly.

 - Real-time backend systems. You've built SSE, WebSocket, or streaming API infrastructure in production — not just consumed it.

 - Strong TypeScript. The API layer and most product features are in TypeScript. You're productive in it.

 Strong plus:

 - Background in developer tools, IDEs, or coding/execution platforms

 - Container runtimes and sandboxed execution (Modal, E2B, Firecracker, or similar)

 - Depth in PostgreSQL, Redis, and Supabase

 - LLM observability and evals tooling (LangSmith or similar)

 - NestJS or equivalent Node.js API framework experience

 - React/Next.js — enough to ship a full-stack feature without handoff

 - Exposure to marketing, growth, or publisher-facing products

 ---

 WHY THIS ROLE IS DIFFERENT

 You own the architecture. Not a feature factory. Not someone else's design doc. The technical execution of an AI product is yours to lead.

 The agent is the product. You're not adding AI to an existing system. You're building and operating the system that is the AI. Every architectural decision

 touches what Juliet can and can't do.

 Hard problems, always. The system spans cloud sandboxes, streaming infrastructure, multi-step agent graphs, and a full-stack web product — for non-technical

 users who can't course-correct a broken output. The bar is high.

 Small team, real leverage. Your code ships to users the same week. No layers of approval.

 ---

 HOW TO APPLY

 Send us:

 1. A short note on the most complex agentic system you've shipped: what broke, and what you'd redo. A link to something you've built that involves agent graphs, tool use, or autonomous multi-step execution

 2. What is one thing you would improve about Juliet? It could be a feature or a bug.

2–4 years of experience in backend development with Python or Golang.

● Solid understanding of RESTful APIs, microservices, and distributed systems.

● Strong knowledge of data structures, algorithms, and OOPS principles.

● Hands-on experience with relational and/or NoSQL databases.

● Familiarity with Linux development, Docker, and basic cloud concepts

(AWS/GCP/Azure).

● Proficiency with Git and version control workflows.

● Familiarity with AI-powered development tools or exposure to projects involving large

language models (LLMs) is a plus.

Strong analytical and debugging skills with the ability to solve complex problems.

About NonStop io Technologies

NonStop io Technologies is a value-driven company with a strong focus on process-oriented software engineering. We specialize in Product Development and have a decade's worth of experience in building web and mobile applications across various domains. NonStop io Technologies follows core principles that guide its operations and believes in staying invested in a product's vision for the long term. We are a small but proud group of individuals who believe in the 'givers gain' philosophy and strive to provide value in order to seek value. We are committed to and specialize in building cutting-edge technology products and serving as trusted technology partners for startups and enterprises. We pride ourselves on fostering innovation, learning, and community engagement. Join us to work on impactful projects in a collaborative and vibrant environment.

Brief Description

We're seeking an experienced Senior Backend Engineer/Tech Lead to join our team. As a backend engineer, you will be responsible for designing, developing, and deploying scalable backends for the products we build at NonStop. This includes APIs, databases, and server-side logic. Also, guiding the mentoring the junior team members

Responsibilities

• Design, develop, and deploy backend systems, including APIs, databases, and server-side logic
• Write clean, efficient, and well-documented code that adheres to industry standards and best practices
• Code Quality: Ensure code quality through code reviews, adherence to best practices, and continuous improvement
• Mentorship: Guide and mentor team members, fostering growth and innovation
• Collaboration: Work closely with stakeholders to align technical goals with business objectives
• Problem-Solving: Analyze and resolve technical challenges promptly
• Innovation: Stay updated with the latest technology trends and integrate them into solutions

Requirements

• At least 5+ years of experience building scalable and reliable backend systems
• Strong expertise in NodeJS/NestJS, Express, PostgreSQL
• Experience with microservices architecture and distributed systems
• Proficiency in database design (SQL and NoSQL)
• Knowledge of cloud platforms (AWS, Azure, or GCP) and CI/CD pipelines
• Deep understanding of design patterns, data structures, and algorithms
• Hands-on experience with containerization technologies like Docker and orchestration tools like Kubernetes
• Familiarity with Frontend Development Technologies (React, JavaScript, HTML, CSS)
• Exceptional communication and leadership skills
• Strong understanding of object-oriented programming principles and design patterns
• Familiarity with automated testing frameworks and methodologies
• Excellent problem-solving skills and attention to detail
• Strong communication skills and ability to effectively lead and maintain a collaborative team environment

Why Join Us?

• Opportunity to work on a cutting-edge healthcare product
• A collaborative and learning-driven environment
• Exposure to AI and software engineering innovations
• Excellent work ethic and culture

If you're passionate about technology and want to work on impactful projects, we'd love to hear from you!