Fullstack Developer at Primathon · Gurugram · 3 - 5 years · Profitable · Posted 24 Sep 2026

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.

About Primathon
About
If Tech is the future, we are a company of future building.
Presenting Primathon, your one stop solution for all tech related challenges for your company. From in-house product development to a dedicated development team for your workplace, we provide every possible solution that can help your organization GROW!
And how do we do that? The answer lies in the way we build our team of developers to ensure the work is done no matter what!
We also take pride in building a culture of growth in our organization that ensures the efficiency and effectiveness of every individual. Where our urge to create a healthy environment, helps us drive better results every year.
With a team of enthusiastic Engineers whose passion is to build technologies of the future, we have ensured a 10x growth in the skillsets of our employees, and drive them towards a better space to work and excel in their abilities.
Similar jobs (10)
Applications on this job are not being reviewed actively. You may apply but please follow up with the company via other channels too.
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!
Applications on this job are not being reviewed actively. You may apply but please follow up with the company via other channels too.
About the Role
We are hiring a Backend Engineer to build and operate the services that power a leading technology marketplace being relaunched under new ownership.
You will work behind the GraphQL federation, inside the ~40 microservices that own billing, subscriptions, the catalog, RBAC, the proxy's control plane, and the Analytics/Quota services. The runtime is Node.js/TypeScript on AWS EKS, with Aurora MySQL / Postgres and DynamoDB for state, Redis / Elasticache / Couchbase for caching, Kafka (MSK) and Kinesis as the event backbone, and ClickHouse for real-time analytics reads. Every consumer-to-provider call passes through the proxy your services configure, and every dollar of marketplace revenue flows through the commerce code your services own.
Roles and Responsibilities
- · Build and operate services — Design, ship, and run Node.js/TypeScript services that sit behind the GraphQL federation. Own a slice of the ~40-service estate end-to-end: API design, schema, persistence, tests, deployment, on-call.
- GraphQL federation subgraphs — Add types, resolvers, and capabilities to the federated Platform API. Keep subgraph boundaries clean; respect RBAC at the federation enforcement layer.
- Commerce backbone — Build the subscription, invoicing, overage, dispute, and payout flows that integrate with Stripe and PayPal webhooks and the billing state machine. Make sure metering, billing, and payouts stay accurate, auditable, and replayable.
- Proxy control plane — Build the management APIs and background workers that configure the runtime proxy: API keys, plans, rate-limit policies, quota caches, abuse signals.
- Event-driven systems — Produce and consume Kafka and Kinesis events safely: schema evolution, idempotency, retries, dead-letter handling. Operate Lambda consumers where they're the right tool.
- Data services — Help own the Node.js Analytics Service and Quota Service that front ClickHouse and Snowflake. Keep latency low, queries cheap, and authorisation correct.
- Performance and reliability — Diagnose hot paths, tune queries, add caches where they matter, and remove caches that have become liabilities. Write the SLOs and the alerts that defend them.
- Security isolation — Implement OAuth2 / JWT / mTLS where they belong; respect least-privilege; design APIs that fail closed.
- On-call and incident response — Take part in the rotation. Lead investigations across services when something rooted in your area breaks.
- LLM-assisted engineering — Use LLM-based coding and agentic tooling to evolve how features are designed, reviewed, and tested.
What Success Looks Like
• Services you own meet their SLOs, deploy multiple times a day, and rarely wake anyone up.
• Billing, subscription, overage, and payout flows you ship are accurate to the cent, replayable, and trusted by both providers and consumers.
• GraphQL subgraphs you maintain stay fast, well-typed, and pleasant to extend.
• Event pipelines you produce and consume are idempotent, observable, and survive replay and back-pressure.
• The first generation of agent-native primitives you help build land in production and start carrying real agent traffic.
What You Bring
• 5–8 years of backend engineering experience, with non-trivial work on production services that real customers depended on.
• Strong TypeScript / Node.js in a production service environment; comfort with async patterns, streams, and back-pressure.
• Solid API design — REST and GraphQL (ideally federation: Apollo Federation, Mercurius, or similar). Schema design, persisted queries, performance tuning.
• Production fluency with SQL — MySQL and/or Postgres. Bonus for Redis or ClickHouse.
• Experience with event-driven systems — Kafka or similar. You understand idempotency, exactly-once myths, and consumer lag.
• Hands-on AWS (EKS, MSK, Kinesis, DynamoDB, Lambda, DMS) and Kubernetes. Comfortable reading and writing Terraform.
• Modern engineering practice: observability, feature flags, CI/CD, and safe rollouts.
• Care for correctness on the money path — you have shipped billing, metering, or payment code before and have the scars to show for it.
• Bonus: experience with API gateways, rate limiting, quota enforcement, usage metering, agent protocols (MCP, A2A, x402), or LLM-based developer tooling.
• You write small, reviewable PRs. You add the test before you fix the bug. You would rather ship a smaller thing well than a bigger thing badly.
Applications on this job are not being reviewed actively. You may apply but please follow up with the company via other channels too.
About the Role
We are hiring a Backend Engineer to build and operate the services that power a leading technology marketplace being relaunched under new ownership.
You will work behind the GraphQL federation, inside the ~40 microservices that own billing, subscriptions, the catalog, RBAC, the proxy's control plane, and the Analytics/Quota services. The runtime is Node.js/TypeScript on AWS EKS, with Aurora MySQL / Postgres and DynamoDB for state, Redis / Elasticache / Couchbase for caching, Kafka (MSK) and Kinesis as the event backbone, and ClickHouse for real-time analytics reads. Every consumer-to-provider call passes through the proxy your services configure, and every dollar of marketplace revenue flows through the commerce code your services own.
Roles and Responsibilities
· Build and operate services — Design, ship, and run Node.js/TypeScript services that sit behind the GraphQL federation. Own a slice of the ~40-service estate end-to-end: API design, schema, persistence, tests, deployment, on-call.
· GraphQL federation subgraphs — Add types, resolvers, and capabilities to the federated Platform API. Keep subgraph boundaries clean; respect RBAC at the federation enforcement layer.
· Commerce backbone — Build the subscription, invoicing, overage, dispute, and payout flows that integrate with Stripe and PayPal webhooks and the billing state machine. Make sure metering, billing, and payouts stay accurate, auditable, and replayable.
· Proxy control plane — Build the management APIs and background workers that configure the runtime proxy: API keys, plans, rate-limit policies, quota caches, abuse signals.
· Event-driven systems — Produce and consume Kafka and Kinesis events safely: schema evolution, idempotency, retries, dead-letter handling. Operate Lambda consumers where they're the right tool.
· Data services — Help own the Node.js Analytics Service and Quota Service that front ClickHouse and Snowflake. Keep latency low, queries cheap, and authorisation correct.
· Performance and reliability — Diagnose hot paths, tune queries, add caches where they matter, and remove caches that have become liabilities. Write the SLOs and the alerts that defend them.
· Security isolation — Implement OAuth2 / JWT / mTLS where they belong; respect least-privilege; design APIs that fail closed.
· On-call and incident response — Take part in the rotation. Lead investigations across services when something rooted in your area breaks.
· LLM-assisted engineering — Use LLM-based coding and agentic tooling to evolve how features are designed, reviewed, and tested.
What Success Looks Like
• Services you own meet their SLOs, deploy multiple times a day, and rarely wake anyone up.
• Billing, subscription, overage, and payout flows you ship are accurate to the cent, replayable, and trusted by both providers and consumers.
• GraphQL subgraphs you maintain stay fast, well-typed, and pleasant to extend.
• Event pipelines you produce and consume are idempotent, observable, and survive replay and back-pressure.
• The first generation of agent-native primitives you help build land in production and start carrying real agent traffic.
What You Bring
• 5–8 years of backend engineering experience, with non-trivial work on production services that real customers depended on.
• Strong TypeScript / Node.js in a production service environment; comfort with async patterns, streams, and back-pressure.
• Solid API design — REST and GraphQL (ideally federation: Apollo Federation, Mercurius, or similar). Schema design, persisted queries, performance tuning.
• Production fluency with SQL — MySQL and/or Postgres. Bonus for Redis or ClickHouse.
• Experience with event-driven systems — Kafka or similar. You understand idempotency, exactly-once myths, and consumer lag.
• Hands-on AWS (EKS, MSK, Kinesis, DynamoDB, Lambda, DMS) and Kubernetes. Comfortable reading and writing Terraform.
• Modern engineering practice: observability, feature flags, CI/CD, and safe rollouts.
• Care for correctness on the money path — you have shipped billing, metering, or payment code before and have the scars to show for it.
• Bonus: experience with API gateways, rate limiting, quota enforcement, usage metering, agent protocols (MCP, A2A, x402), or LLM-based developer tooling.
• You write small, reviewable PRs. You add the test before you fix the bug. You would rather ship a smaller thing well than a bigger thing badly.
Applications on this job are not being reviewed actively. You may apply but please follow up with the company via other channels too.
About the Role
We're looking for engineers who can independently design and build reliable backend services. Beyond writing code, you should be comfortable thinking about performance, data consistency, reliability, and maintainability.
Responsibilities
● Design and implement backend services.
● Translate business requirements into technical solutions.
● Design efficient database schemas.
● Build reliable asynchronous workflows.
● Debug production issues independently.
● Review code and mentor junior engineers.
● Improve application performance and reliability.
● Contribute to technical design discussions.
Must Have Strong Programming Skills
● Proficiency in at least one backend language.
● Strong Object-Oriented Design.
● Good understanding of design principles.
● REST API design.
● Writing maintainable, testable code.
Database Knowledge Comfortable with:
● Database design
● Query optimization
● Transactions
● Indexing strategies
● Locking (high-level understanding)
● Isolation levels (basic understanding)
● Data modelling Concurrency
Working knowledge of:
● Race conditions
● Concurrent updates
● Idempotency (basic understanding)
● Optimistic vs pessimistic locking (conceptual)
● Thread safety (language dependent)
Asynchronous Systems Experience with:
● Background jobs
● Queues
● Retry mechanisms
● Scheduled jobs
● Event-driven workflows (nice to have)
Problem Solving Should be comfortable:
● Debugging production issues.
● Reading logs.
● Identifying bottlenecks.
● Breaking large features into smaller tasks.
● Evaluating trade-offs before implementation.
Good to Have Experience with:
● Redis
● RabbitMQ / Kafka / BullMQ or similar
● Docker
● Kubernetes
● AWS
● CI/CD
● Monitoring & Logging tools
What We Look For Successful engineers here typically:
● Think before coding.
● Write maintainable solutions.
● Understand why a design works, not just how.
● Consider edge cases.
● Take ownership of production issues.
● Help improve the engineering practices of the team.
Interview Focus
● Programming fundamentals
● Database design
● SQL
● Concurrency scenarios
● API design
● Production debugging
● Problem-solving exercise
● Code review discussion
Applications on this job are not being reviewed actively. You may apply but please follow up with the company via other channels too.
We are looking for a Backend Engineer (SDE 2) to build scalable backend systems for EV charging infrastructure and energy management platforms. The role focuses on developing high-performance APIs, event-driven systems, and data pipelines that process EV telemetry, charging sessions, and energy analytics.
What You'll Own
- Design and develop scalable backend services and RESTful/WebSocket APIs.
- Build microservices using Go.
- Design and optimize databases for high-volume telemetry and charging-session data.
- Build event-driven systems and data pipelines using Kafka or similar messaging systems.
- Work on real-time and batch processing workflows for telemetry, energy metrics, and analytics.
- Improve application reliability, performance, monitoring, and observability.
- Deploy and operate services using Docker and Kubernetes.
- Participate in system design, architecture discussions, code reviews, testing, and technical documentation.
- Mentor and support junior engineers when required.
Required Qualifications
- 3 - 5+ years of backend development experience building scalable APIs and microservices.
- Strong proficiency in Golang.
- Strong understanding of PostgreSQL, MongoDB, or other relational/NoSQL databases.
- Experience with query optimization, indexing, schema design, partitioning, or replication.
- Experience building event-driven or distributed systems using Kafka or similar messaging systems.
- Familiarity with GCP or other cloud platforms.
- Experience with Docker and Kubernetes.
- Experience with monitoring and observability tools such as Grafana, Kibana, or ELK.
- Strong understanding of system design, scalability, and performance optimization.
- Experience writing clean, maintainable, testable code with unit and integration tests.
Nice to Have
- Experience working with EV charging, energy management, mobility, or IoT platforms.
- Experience processing high-volume telemetry or time-series data.
- Experience with real-time data processing and analytics pipelines.
- Experience with WebSockets or other real-time communication protocols.
- Experience with CI/CD and production infrastructure.
- Experience working with distributed systems at scale.
Why Join Us
- Build backend infrastructure powering EV charging and energy platforms.
- Work on distributed systems, real-time data, and high-volume telemetry.
- Solve challenging problems around scalability, reliability, and performance.
- Take meaningful ownership of production systems and technical decisions.
Applications on this job are not being reviewed actively. You may apply but please follow up with the company via other channels too.
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. We're seeking an experienced Backend Software Engineer 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.
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
● Participate in code reviews and contribute to the improvement of the codebase
● Debug and resolve issues in the existing codebase
● Develop and execute unit tests to ensure high code quality
● Work with DevOps engineers to ensure seamless deployment of software changes
● Monitor application performance, identify bottlenecks, and optimize systems for better scalability and efficiency
● Stay up-to-date with industry trends and emerging technologies; advocate for best practices and new ideas within the team
● Collaborate with cross-functional teams to identify and prioritize project requirements
Requirements:
● At least 3+ 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
● 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 environmen
● Ready to be a tech-agnostic engineer and comfortable to shift on any tech stack (Java, Node, Python etc)
● Comfortable working with AI (Claude code, Cursor etc)
Applications on this job are not being reviewed actively. You may apply but please follow up with the company via other channels too.
Role Description
Software Engineer is a full-time role based in Hyderabad with Onsite work arrangement. This role involves designing, developing, and maintaining back-end services and APIs, ensuring high performance, scalability, and security across platforms. The engineer will participate in architecture discussions, code reviews, and technical decision-making, collaborating closely with product owners, QA, and cross-functional teams. Daily responsibilities include writing clean, maintainable code, troubleshooting complex issues, improving system performance, and contributing to best practices, documentation, and engineering standards. The role also includes mentoring less experienced engineers and supporting continuous improvement in development processes and tooling.
Key Requirements/Skills
4-7 years of overall experience in software development with strong expertise in building scalable web & mobile applications.
- Strong technical decision-making ability, including architecture design, technology selection and implementation of best practices.
- Front-end expertise: Strong experience in React, JavaScript, TypeScript, NextJS and building responsive and user-friendly UI/UX.
- Back-end development: Hands-on experience with Node.js, Express JS, Nest JS, RESTful APIs, API design, and server-side architecture.
- Databases : Good Hands on Exprience in both SQL(PostgreSQL Preferred) & No SQL Databases
- Gen AI Expertise: Experience in building RAG & LLM Systems, implementing AI/ML models and integrating AI-based solutions to solve business problems. Expereince with Langchain, langgraph and Vector DBs, Voice AI(STT, TTS) Models and experience in using Open AI Tools (Calude, Cursor, etc.)
- Cloud & DevOps exposure: Experience with AWS/Azure, understanding of CI/CD pipelines, and cloud-based deployments.
- Code quality & best practices: Experience in code reviews, Git version control, and ensuring maintainable and secure code.
- Team leadership: Ability to mentor developers, guide technical discussions, and collaborate across teams.
- Strong communication skills to effectively interact with technical and non-technical stakeholders.
- Experience working in high-compliance environments such as healthcare systems is a plus.
- Certifications in AWS & Other skills and technologies will be an added advantage.
Educational Qualification
- B.Tech / M.Tech in CSE/IT/AI&ML only from a recognized university/college.
Applications on this job are not being reviewed actively. You may apply but please follow up with the company via other channels too.
About AbleCredit:
AbleCredit is on a mission to solve the Credit Gap of emerging economies. In India alone, the Credit Gap is over USD 5T (Trillion!). This is the single largest contributor to poverty, poor genie index and lack of opportunities.
Ablecredit is a rare startup because we are probably the only revenue generating GenAI startup in India.
Key Responsibilities:
● Solving highly complex technical challenges and driving large-scale projects; developing robust and scalable web applications using Node.js, MongoDB
● Participate in system design, architecture, and help build scalable, high-performance systems
● Mentor junior engineers (SDEs and SDE-2s), driving technical decisions, and leading entire projects or initiatives
● Conduct code reviews and provide constructive feedback to team members.
● Architect efficient and reusable back-end systems and optimize applications for maximum speed and scalability.
● Implement security and data protection measures.
● Stay updated on emerging technologies and best practices in web development.
Qualifications:
● Bachelor' s degree in Computer Science, Engineering, or a related field.
● Minimum of 5 years of experience in backend web development.
● Proficiency in Node.js and typescript along with their core principles.
● Experience with server-side frameworks such as Express.js.
● Familiarity with database systems such as MongoDB, or PostgreSQL.
● Knowledge of RESTful APIs and asynchronous request handling.
● Excellent problem-solving and troubleshooting skills.
● Ability to work independently and as part of a team in a fast-paced environment.
● Effective communication skills and the ability to collaborate with stakeholders.
● Bonus: can whip up a front end or UI with AI agents or all by yourself.
Applications on this job are not being reviewed actively. You may apply but please follow up with the company via other channels too.
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
Applications on this job are not being reviewed actively. You may apply but please follow up with the company via other channels too.
Job Role: Software Engineer – Backend & Cloud Infrastructure
Company: Appmaker by StarApps
Location: Kochi, Kerala (On-Site)
Experience: 3–6 Years
Employment Type: Full-time
About Appmaker by StarApps
At StarApps, we build high-scale tools like Appmaker(https://appmaker.xyz/) that empower thousands of global e-commerce merchants to turn their web stores into native mobile apps. We focus on low latency, cutting-edge serverless architectures, and building scalable software that handles millions of requests every day.
About the Role
We are looking for a Mid-Senior Backend & Cloud Infrastructure Engineer to join our core team on-site in Kochi. In this role, you will design, scale, and maintain high-throughput backend services and cloud infrastructure capable of supporting large user bases and handling millions of daily requests.
If you thrive in solving complex distributed system design challenges, optimizing cloud infrastructure, and taking ownership of core platform scaling, this role is for you!
Key Responsibilities
- Distributed Backend Systems: Architect, construct, and optimize core backend microservices and serverless applications built on Node.js and TypeScript.
- Cloud Infrastructure & DevOps: Manage, automate, and expand infrastructure across cloud platforms (AWS, GCP, or Azure) using IaC (Terraform, Ansible) and container technologies (Docker, Kubernetes).
- System Scalability & Performance: Design for high availability, implementing caching, load balancing, message queues, and database optimizations.
- Reliability & Observability: Troubleshoot complex production incidents, optimize system latency, enforce security standards, and maintain CI/CD and automated monitoring pipelines.
- Architecture Ownership: Own critical features and system components independently while collaborating on high-level architecture decisions.
What We’re Looking For
- Experience: 3–6 years of hands-on software development experience with a focus on backend software architecture, systems engineering, and infrastructure.
- Tech Stack: Strong mastery of Node.js, JavaScript, and TypeScript.
- Cloud & DevOps: Hands-on experience with Docker, Kubernetes, Terraform, Ansible, and major Cloud Providers (AWS, GCP, or Azure).
- Edge & Serverless: Deep understanding of serverless deployment models (Cloudflare Workers/D1, AWS Lambda, or equivalent).
- System Design & Databases: Advanced knowledge of system design, load balancing, caching strategies, asynchronous message queues, relational database optimization, and high-availability architecture.
- Engineering Standards: Strong experience with production CI/CD, observability tools, automated testing, and production troubleshooting.
Bonus Points
- Hands-on experience with the extended Cloudflare suite (KV, R2, Queues, Workers).
- Prior experience in SaaS product engineering, Shopify app ecosystems, or high-traffic global e-commerce platforms.
Why Join Us?
- High Scale & Impact: Build software used by thousands of global brands and millions of end consumers.
- Modern Tech Stack: Work with cutting-edge serverless architectures and infrastructure automation platforms.
- Growth & Culture: Great engineering culture, high ownership, competitive growth, and direct technical leadership opportunities in our Kochi office.














