Senior Technical Architect at Cibirix · Indore · 10 - 15 years · ₹10L - ₹45L / yr · Profitable · Posted 10 Jul 2026

Key Focus Areas:-
• Scalable SaaS and distributed systems
• Microservices architecture
• Backend performance and API optimization
• Cloud infrastructure and DevOps
• Multi-tenant platforms
• Reliability, scalability, and engineering governance
Main Responsibilities:-
• Design fault-tolerant backend systems
• Lead architecture decisions and technical planning
• Improve system performance, scalability, and deployment workflows
• Guide senior developers and enforce engineering standards
• Reduce technical debt and solve complex production issues
• Collaborate with DevOps on CI/CD, monitoring, and AWS infrastructure.
• You will work on complex, enterprise-scale systems including large SaaS platforms, distributed backend architectures, pricing intelligence engines, CRM solutions, 3D configuration ecosystems, route optimization modules, payment integrations, high-volume APIs, and modern cloud infrastructure.
• We are not looking for a “people manager who used to code.
Required Skills:-
• Backend: Node.js, TypeScript, REST APIs, event-driven systems
• Frontend Understanding: React.js architecture concepts
• Databases: PostgreSQL, MySQL, Redis, query optimization
• Cloud/DevOps: AWS, Docker, CI/CD, Kubernetes (preferred)
• System Design: Microservices, distributed systems, high-availability SaaS platforms
Preferred Experience:-
• SaaS product companies
• Enterprise CRM systems
• Large-scale production platforms
• Pricing engines, WebGL/3D systems, AI-assisted workflows
• U.S.-based product engineering environments
Experience Needed:-
• 10–15 years in software engineering
• 3+ years in architect/principal engineer/engineering lead roles
• Proven experience building scalable production systems
Ideal Candidate:-
A technically strong, ownership-driven architect who:
• Thinks strategically
• Stays calm under pressure
• Solves complex engineering problems
• Mentors teams effectively
• Builds long-term scalable systems rather than quick fixes

Similar jobs (10)
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!
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.
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.
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.

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)
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.
Most software was written for people to read. We are rebuilding a large, mature codebase so that AI agents can read it, change it and ship it too, without breaking what already works.
In this role you will decide how the system should be cut up and what each piece promises to the others. You will put legacy logic behind clear contracts, one safe step at a time. You will design the data models, APIs and tests that keep behavior correct under load, retries and failure. You will build the MCP tools and agent context that agents rely on, and you will set the bar for what AI-written code must meet before it merges.
You will work hands-on, not from the sidelines, and you will own your work from design through production. You will also explain your trade-offs clearly to engineers, QA, operations and product, and bring them along with your decisions. The role is remote and on contract, with a globally distributed team. It suits an architect who reasons from first principles, uses AI tools daily with healthy skepticism, and is comfortable with open-ended problems.
WHAT YOU WILL DO
Design systems that agents can operate
- Break legacy monoliths into modular systems with strict boundaries, single responsibility and clear contracts.
- Lead incremental modernization using the Strangler Pattern, wrapping legacy logic behind modern, contract-first interfaces.
- Design data models, keys and constraints from the queries and rules the system must always uphold, and enforce integrity in the database instead of leaving it only to application code.
- Apply SOLID principles, dependency injection and hexagonal architecture so AI-generated changes stay deterministic and regressions stay low.
- Design for real-world cases: simultaneous requests, retries and duplicate messages, partial failures, and changes to data that already exists.
Build the agent and MCP layer
- Build and maintain the agent context layer: shared skills, rules and commands for AI-driven engineering workflows.
- Build and run Model Context Protocol (MCP) servers that expose legacy APIs, services and databases as typed, permissioned, auditable tools.
- Own contract-first API design as the main interface between human intent and agent execution.
- Design agent loops with clear tools, permissions and stop conditions, and tune them for cost, speed and quality.
Keep AI-written code trustworthy
- Review AI-generated pull requests for correctness, security, scalability and maintainability. Check that tests assert real behavior and do not just pass.
- Require test-first development and characterization tests that preserve legacy behavior during refactoring.
- Set the review habits, checklists and guardrails that help the wider team use AI tools well, and know when not to use them.
Own outcomes and work across the business
- Take responsibility from design through production, including monitoring, incidents and follow-up.
- Ask the right questions up front, explain trade-offs in plain language, and bring product, QA and operations teams along with your decisions.
- Mentor engineers and set a consistent standard for design and code quality.
WHAT WE ARE LOOKING FOR
- 6+ years in software architecture, platform engineering or technical leadership.
- Proven experience modernizing large, poorly documented legacy systems.
- Strong hands-on depth in TypeScript and Node.js, or in .NET. Depth in one is enough.
- Strong command of API design, relational data modeling, SQL, transactions and concurrency.
- Solid system design fundamentals: queues, caches, background workers, sync versus async, and what breaks first as load grows.
- Practical, day-to-day use of AI coding tools on real projects, with a deliberate workflow, a habit of verifying output and a clear view of the risks. Experience building agents, MCP servers or AI tooling is a strong plus.
- A bias toward clean code, tests first, deterministic systems and production-grade AI.
- Clear written and spoken communication, and the independence to work with little day-to-day oversight.
NICE TO HAVE
- Experience with remote-first or globally distributed teams.
- Background in SaaS transformations, scale-ups or private equity-backed environments.
- Comfort in high-ambiguity, high-ownership settings.
HOW WE HIRE
Expect an online assessment followed by technical conversations where you will reason through data models, queries and designs in plain language, and explain how you use AI tools in your own work. We are looking for sound thinking and honest answers, so please be ready to explain your own resume claims in detail.

Senior Software Engineer – SRE Products (Full Stack)
Work Mode: Remote
Experience: 7+ Years
Employment Type: Full-Time
Job Overview
We are looking for a skilled Senior Software Engineer to join our SRE Product Team. The ideal candidate should have strong expertise in Python, backend development, Node.js/TypeScript and AWS cloud technologies.
The role involves developing scalable applications, automation platforms, observability solutions and reliability engineering tools.
Key Responsibilities
- Design and develop scalable backend applications, REST APIs and microservices.
- Build automation platforms and self-service engineering tools.
- Develop cloud-native applications using AWS services.
- Build frontend interfaces using React or Angular.
- Implement monitoring, observability and application reliability solutions.
- Work with platform and cloud engineering teams to improve system performance.
Required Skills
- 7+ years of software engineering experience.
- Strong hands-on experience in Python.
- Good experience with Node.js, JavaScript and TypeScript.
- Expertise in REST APIs, Microservices and Backend Development.
- Hands-on experience with AWS (Lambda, ECS/EKS, API Gateway, DynamoDB, RDS, CloudWatch).
- Experience with React or Angular.
- Knowledge of Docker, Kubernetes and OpenShift.
- Experience with CI/CD pipelines and Terraform.
- Understanding of SRE principles, monitoring and observability.
Good to Have
- Dynatrace, Prometheus, Grafana, Splunk or OpenTelemetry.
- Experience building internal developer platforms.
- Exposure to AIOps, AI Agents or MCP.
Position Overview
The Senior Full-Stack Developer will design, develop, and maintain enterprise-grade applications software platforms, with a primary focus on TrackerCheck and related APIs, admin web, and mobile clients.
This role requires expertise across TypeScript, React, Node.js/Express, and C#/.NET, working with MySQL and AWS as the primary data and cloud platforms. You will collaborate with cross-functional teams to deliver high-quality, scalable solutions that serve major global energy companies.
Reporting to the Director of Development, the Senior Full-Stack Developer will work on both greenfield projects and enhancements to existing platforms, contributing to all phases of the software development lifecycle.
Key Responsibilities
• Design, develop, and maintain full-stack web applications using TypeScript, React (react-admin), Node.js/Express, and C#/ASP.NET Core
• Build and optimize RESTful APIs using Express.js and ASP.NET Core for enterprise-scale, multi-tenant applications
• Develop responsive, intuitive user interfaces using React, react-admin, and modern frontend libraries (MUI, enterprise data grids)
• Design and implement database schemas, queries, migrations, and optimizations for MySQL using Sequelize and/or Entity Framework
• Implement authentication and authorization using JWT, OAuth, AWS Cognito, and RBAC
• Integrate applications with AWS services including Lambda, S3, SQS, Cognito, and related container/ECS workloads
• Write clean, maintainable, and well-tested code (Jest, Cypress)
• Participate in code reviews, technical discussions, and architecture decisions
• Troubleshoot and resolve production issues across the full technology stack
• Contribute to API documentation and maintain technical documentation
Job Requirements
Required
• 8+ years of professional full-stack development experience
• TypeScript — strong proficiency across backend and frontend
• Node.js / Express — production REST APIs, middleware, services, and background workers
• React — complex SPA development; react-admin (or equivalent admin/RBAC data-grid UIs) strongly preferred
• Proven experience building and deploying production REST APIs, with a deep understanding of architecture and design patterns
• MySQL — schema design, queries, and migrations; Sequelize required (or equivalent ORM with willingness to use Sequelize)
• C# and ASP.NET Core — production API development; Entity Framework preferred
• AWS — practical experience with Lambda, S3, SQS, and Cognito; Docker and containerized deployments
• Authentication and security — JWT, OAuth, Cognito, RBAC, and secure coding practices
• Git, code review, CI, and the ability to troubleshoot production issues across the stack
• Problem-solving mindset, excellent communication, ability to work collaboratively, self-motivated with strong attention to detail and quality
Preferred
• React Native (React Native CLI / EAS) for iOS and Android
• MUI, AG Grid, or similar enterprise grid/form libraries
• ASP.NET Core Identity and dependency injection patterns used in .NET services
Optional
• Oracle Database (SQL, drivers, dual-dialect schema work alongside MySQL)
• Oracle Cloud Infrastructure (OCI) — Functions, Object Storage, Queues, identity, and Autonomous Database. Experience is a plus; AWS remains the primary cloud
Education
Bachelor's degree in Computer Science, Software Engineering, or a related technical discipline (or equivalent professional qualification)
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













