Python Backend Developer

About Tamasha

Tamasha is building next-generation live, social, and real-time consumer

experiences across gaming, audio, video, and interactive platforms. Our backend

systems power millions of real-time interactions, low-latency data flows, and high

throughput event-driven services.

Role Overview

As a Software Development Engineer III (Backend), you will operate as a senior

individual contributor owning mission-critical backend systems. You will design

scalable architectures, solve complex distributed systems problems, and influence

engineering standards across teams.

Roles & Responsibilities

 Own backend systems end-to-end, from design and implementation to

production reliability and long-term evolution.



Design scalable, fault-tolerant, and low-latency backend architectures for real

time and event-driven use cases.



Lead system design decisions including data models, service boundaries, async

workflows, and scalability strategies.



Build and operate high-throughput services handling millions of events, requests,

or messages per day.

 Own reliability metrics such as p95/p99 latency, uptime, error budgets, and

participate in incident resolution and post-mortems.

Drive architectural migrations including monolith to microservices and

synchronous to asynchronous flows.

 Collaborate with product, frontend, and data teams to translate complex

requirements into robust backend solutions.



Improve developer productivity by contributing to internal platforms, tooling,

CI/CD pipelines, and coding standards.



Mentor engineers through design reviews, code reviews, and technical guidance

without direct people management.



Proactively identify performance bottlenecks, cost inefficiencies, and scalability

risks and resolve them at the system level.

Tech Stack

Backend: Node.js (NestJS / Express), Golang, Java

Databases: PostgreSQL, MySQL, MongoDB, Redis

Messaging & Async: Kafka, SQS, RabbitMQ, Pub/Sub

Real-time: WebSockets, Server-Sent Events

Cloud & Infra: AWS / GCP, Docker, Kubernetes

Observability: Prometheus, Grafana, OpenTelemetry

What We’re Looking For

• 5+ years of backend engineering experience

• Proven ownership of production systems at scale

• Strong understanding of distributed systems and async architectures

• Experience handling production incidents and system reliability

• Ability to independently design and evolve backend systems

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.

* Python (3 to 6 years): Strong expertise in data workflows and automation

* Spark (PySpark): Hands-on experience with large-scale data processing

* Pandas: For detailed data analysis and validation

* Delta Lake: Managing structured and semi-structured datasets at scale

* SQL: Querying and performing operations on Delta tables

* Azure Cloud: Compute and storage services

* Orchestrator: Good experience with either ADF or Airflow

Job Title: Senior Linux Kernel Engineer

Experience: 5–10 Years

Location: Bangalore / Chennai

Domain: Enterprise Linux / Kernel Development

Job Summary

We are seeking a highly skilled Senior Linux Kernel Engineer with deep expertise in kernel development, debugging, and performance optimization. The role involves working on enterprise-grade Linux distributions, kernel lifecycle management, security patching, and low-level hardware integration.

Key Responsibilities

1. Kernel Lifecycle & Maintenance

• Lead kernel upgrade strategies (e.g., LTS migrations such as 5.15 → 6.x) while ensuring stability and compatibility.
• Perform patch porting across kernel versions, resolving API and dependency conflicts.
• Track and mitigate security vulnerabilities by monitoring CVEs and upstream sources (e.g., LKML).
• Backport critical fixes to production kernels without impacting system stability.

2. Debugging & System Stability

• Act as an escalation point for kernel panics and system crashes.
• Perform post-mortem analysis using kdump, crash, and gdb.
• Debug early boot issues (UEFI, initramfs, kernel initialization).
• Conduct performance analysis using eBPF, ftrace, and perf to optimize system behavior.

3. Driver Development & Hardware Integration

• Design, develop, and maintain device drivers (network, storage, GPU, or character devices).
• Work closely with hardware through DMA, interrupts (MSI-X), and register-level programming.
• Maintain out-of-tree drivers using DKMS or similar frameworks.
• Ensure compatibility of drivers across kernel updates.

Required Technical Skills

• Programming: Strong expertise in C (mandatory) and C++
• Kernel Internals: Deep understanding of:
• Virtual File System (VFS)
• Memory Management (MMU, Paging)
• Process Scheduler
• Linux Networking Stack
• Debugging Tools:
• kdump, crash, gdb
• kprobes, trace-cmd, ftrace
• perf, valgrind
• Hardware debugging tools (JTAG, Serial Console)
• Build Systems:
• Kbuild, Makefiles
• Kernel packaging (RPM/Debian)
• Security:
• Experience with CVE patching and backporting
• Knowledge of SELinux/AppArmor
• Kernel hardening (FIPS, KSPP)

Preferred Skills

• Experience contributing to open-source kernel projects
• Familiarity with Linux Kernel Mailing List (LKML) workflows
• Exposure to enterprise Linux distributions (RHEL, Ubuntu, SUSE)
• Experience with performance tuning and system optimization at scale

1. Core Programming (C Language)

• Must have strong hands-on experience in C programming
• Comfortable with pointers, memory management, and low-level concepts

2. Kernel Internals Expertise

• Should have worked in at least one subsystem:
• VFS / File Systems
• Memory Management
• Scheduler / Networking

3. Debugging & Crash Analysis

• Experience handling kernel panics
• Hands-on with vmcore analysis tools

4. Security & Patching

• Understanding of CVE fixes and backporting

5. Driver Development

• Experience in writing or maintaining device drivers

6. Performance & Advanced Debugging

• Exposure to eBPF, ftrace, perf

7. Hardware-Level Understanding

• Knowledge of DMA, interrupts, hardware interaction

Soft Skills

• Strong analytical and problem-solving abilities
• Excellent communication skills
• Ability to work independently and in collaborative environments
• Quick learner with adaptability to new technologies

Job description

🔧 Key Responsibilities:

• Design and implement robust backend services using Node.js.
• Develop and maintain RESTful APIs to support front-end applications and third-party integrations
• Manage and optimize SQL/NoSQL databases (e.g., PostgreSQL, MongoDB, Snowflake)
• Collaborate with front-end developers to ensure seamless integration and data flow
• Implement caching, logging, and monitoring strategies for performance and reliability
• Ensure application security, scalability, and maintainability
• Participate in code reviews, architecture discussions, and agile ceremonies

✅ Required Skills:

• Proficiency in backend programming languages (Node.js, Java, .NET Core)
• Experience with API development and tools like Postman, Swagger
• Strong understanding of database design and query optimization
• Familiarity with microservices architecture and containerization (Docker, Kubernetes)
• Knowledge of cloud platforms (Azure, AWS) and CI/CD pipelines.

Company Description

Evoqins is an end-to-end digital product development team focused on maximizing the scalability and reliability of global businesses. We specialize in a wide range of domains including fintech, banking, e-commerce, supply chain, enterprises, logistics, healthcare, and hospitality. With ISO 9001 certification and a 4.9-star Google rating, we are proud to have 120+ satisfied customers and an 87% customer retention rate. Our services include UX/UI design, mobile app development, web app development, custom software development, and team augmentation. 

Role Description

We are looking for a passionate Senior Backend Developer.  You will be responsible for designing, developing, and maintaining scalable backend services and APIs using Python. 

• Role: Senor Backend Developer
• Location: Kochi
• Employment Type: Full Time
• 
  

Key Responsibilities

• Design, develop, and maintain scalable Python-based applications and APIs.
• Build and optimize backend systems using FastAPI/Django/Flask.
• Work with PostgreSQL/MySQL databases, ensuring efficiency and reliability.
• Develop and maintain REST APIs (GraphQL experience is a plus).
• Collaborate using Git-based version control.
• Deploy and manage applications on AWS cloud infrastructure.
• Ensure best practices in performance optimization, testing, and security.
• 
  

Required Skills & Experience

• 2– 5 years of hands-on Python development experience.
• Experience in Fintech projects is an advantage
• Proven experience in FastAPI and REST API development.
• Strong database skills with PostgreSQL (preferred) and MySQL.
• Practical exposure to API integrations and third-party services.
• Experience deploying and maintaining applications in production.
• Familiarity with AWS cloud services.

• BackEnd Technologies:

• Technical knowledge:

• It is important to adapt to changing requirements
• Have the ability to integrate external systems

How many hours are they expected to work? 

• - Full time position ( 40+ hours a week) 
•  

What hours should they work?

•  - Prefer 9-5 EST but there is wiggle room
•  

Will there be nights and weekends? 

• - Nights and weekends are not scheduled, however we are looking for someone that takes pride in their work and will lean in to hit a deadline or to fix a bug if it has a significant impact on the platform.
•  

Should they be expected to lead?

• - Yes, you should be expected to lead and to communicate/ cooperate with other devs as a team. Some coding might be alone but the hope of the app is that it all works seamlessly together and to ensure that there needs to be communication among all devs front end and back end. 
•  

Who will they report to?

• - They will report to Product OwnerRob and Product ManagerJulietta daily for standups and well as pushing tasks through the appropriate structure of review, QA, and production. 
• They will also report and check in with Client SuccessCourtney as we look to make the app have a seamless customer experience and customer value. The goal of Attribute should be to try and give as much value as quickly and easily as possible.

Will they work alone or in a team?

• In some spots they might be expected to work alone and on a separate sprint from others, however, everything needs to tie in and work together, because of that the developer must be team oriented in both development and problem solving.
• Additionally, there will be times that they should expect to work with people who are not particularly tech savvy ( ie. sales, marketing, customer success etc.) to collaborate on a specific feature to produce the best thing for the product.

Accountability

• The developer is both accountable for their code and the code of the team. They should take care and responsibility in the work that is done and if there are problems with the code in QA or production work as diligently as possible to fix that problem ( whether it is their code directly or not).
• As part of this all code will be attached from Github to Jira for developers to constantly upload their commits to Jira tasks
• A mistake is completely fine and expected, bugs are to be expected. What is asked is that you report it as soon as possible and are honest about it so that we can move forward in resolving it as soon as possible.

Customer, Usability, and Value Focused

• The end user of our product will be marketing professionals/head of marketing. At all times the developers need to take this into account and spend time thinking of the ease and the use cases that people will utilize their code or features in real life versus what is a way to make something work but in a vacuum. 

Quality focused

• Pushing out code is awesome, but if the code has a ton of bugs and does not do the required action that is practical for the user then it does not matter. We want a developer who is Quality focused and also hold their other developers accountable.

Focused on the whole 

• When producing a feature it is easy to sometime get sucked into how that features works in a vacuum. The developers need to be able to work together and understand the software architecture as a whole in order to make whatever feature they are working on be able to work with the other features that are built within the app ( and will be built or are on the roadmap for the future).

Creativity and Experimentation

• Developers are expected to work within structures, however, they are always encouraged to take time to think of creative solutions and to collaborate on new features or ways of making the product better.

Unfeathered, Honest, Respectful Communication

• Every developer should feel free to speak their mind in a respectful manner to other developers as well as anyone else in the entirety of the company. Any opinion, thought, or perspective will be listened to and valued. 

Next Man or Woman Up Mentality

• Never should anyone on the team defer a problem and say “ thats not my fault or problem”. We are one unit and one company. One problem is everyone's problem and should lean in to the “next man up philosophy” if you have the time and can help to fix the problem and bring it to a solution you should be willing to.

Upward Mobility and Vesting Opportunity

• This position will allow for upward mobility, increased responsibility, and for people who constantly go above and beyond an opportunity to vest into and own equity in the company

• Have at least 3 years work experience in Java 8 or higher / J2EE Java development.

• Have experience of agile systems development methodologies such as SCRUM
• Experience in designing the solution and implementation.
• Is a communicative, positive, outgoing and driven team player.
• Solution-oriented, see opportunities and proactively proposing new solutions, speak and write fluently in English.
• Good to have certifications in Java, Spring etc.
• Experience in Java 8.

• Experience in Spring Boot and other spring framework like Spring data, AOP etc.
• Experience in MongoDB/ Kafka / RabbitMQ etc.
• Experience in REST API
• Have worked on microservices
• Should have worked on minimum 2- 3 projects
• Experience in writing effective Unit test case for better coverage.
• Experience in writing good quality code by following code quality tools likes SonarQube etc.