Blockchain Backend Engineer – NFT Records & Tokenization

About the Organisation

DataFlow Group is a pioneering global provider of specialized Primary Source Verification (PSV) solutions, and background screening and immigration compliance services that assist public and private organizations in mitigating risks to make informed, cost-effective decisions regarding their Applicants and Registrants.

DataFlow with its best practices in this field such as a high level of data security, cutting-edge technology, rigorous processes, qualified research analysts, and a global network of over 100,000 issuing authorities, verifies professionals credentials from the primary issuer of the document - regardless of its nature.The company complements its advanced verification processes and long-standing industry expertise by adhering to the highest regulatory standards, including the Joint Commission International (JCI), International Organization for Standardization (ISO), and the European Union’s General Data Protection Regulation (GDPR).

About the Role:

We are looking for a Backend Architect / Lead who lives and breathes code. This isn't a role for someone who wants to delegate; it’s for a technical heavyweight who wants to own core product development, define backend architecture patterns, and build scalable, secure, and resilient systems from the ground up. You will join a fast-paced environment where we ship high-quality code under tight timelines. You’ll be expected to take full ownership of our server-side ecosystem, database design, and API layer, ensuring high availability, bulletproof operational excellence, and top-tier performance.

Duties and Responsibilities:

● Architect & Build: Design and implement complex, scalable microservices and monolithic architectures using Node.js, Express.js, and MongoDB (MERN backend stack).

● Heavyweight Coding: Spend the majority of your time writing high-quality, production-ready backend code. You should be comfortable solving complex systems problems using efficient Data Structures, Algorithms, and clean architecture principles.

● Performance & Data Engineering: Own database optimization, query performance, indexing strategies, caching layers (Redis), and system throughput to ensure low-latency API response times.

● Technical Leadership: Establish and enforce industry best practices for REST/GraphQL API design, security standards, code reviews, and automated CI/CD pipelines.

● End-to-End Ownership: Participate in the full SDLC—from initial ideation and system design to deployment, infrastructure setup, and production monitoring on AWS

Qualifications:

● The Deep Diver: You have spearheaded at least one large-scale, complex backend project or system redesign. You can explain every architectural decision, trade-off, database schema choice, and line of code in a deep-dive technical discussion.

● Experience: You have at least 8 years of professional software development experience, with a significant focus on high-traffic, distributed backend systems.

● Tech Stack Mastery: Expert-level proficiency in Node.js, Express.js, MongoDB (Mongoose/Aggregation framework), and TypeScript. Strong hands-on experience with AWS (EC2, S3, ECS/Lambda, CloudWatch) and containerization (Docker).

● Architectural Fluency: A solid understanding of modern backend patterns (Microservices, Event-Driven Architecture, Pub/Sub, Caching strategies, Message Queues like RabbitMQ/Kafka, State Management, and Authentication/Authorization protocols).

● Optimization Expert: Proven experience in tuning database performance, scaling server instances, managing connection pools, and debugging memory leaks or high CPU usage under heavy load.

● Grit & Speed: You thrive in high-pressure environments and enjoy the challenge of meeting tight deadlines without compromising on quality or system reliability.

Senior / Staff Software Engineer – Backend Engineering

Experience: 7+ years

Location: India

Role Type: Individual Contributor | Hands-on Engineering

About the Role

Oddr is looking for a deeply hands-on Senior / Staff Software Engineer who combines strong backend engineering fundamentals with an AI-first way of building software.

This is not a traditional development role where AI is used only for code completion. We are looking for engineers who can understand a problem, design the right solution, define architectural and security guardrails, and then use AI aggressively to accelerate implementation without compromising quality.

You will be expected to code regularly, own solutions end-to-end, build POCs, drive technical design, review critical code, and help raise the engineering bar across the team.

This is not a people-management role.

What You’ll Do

• Design and build scalable, secure backend systems using C# / .NET.
• Own features from problem definition and architecture through coding and production delivery.
• Use AI coding tools such as Claude Code, Codex, Cursor or GitHub Copilot to accelerate development.
• Define the right context, constraints, tests and guardrails around AI-generated code.
• Build POCs and evaluate technical approaches before scaling them into production.
• Drive system design, API design, data modelling and integration decisions.
• Review code for correctness, security, performance and maintainability.
• Build automated tests, observability and validation into the development lifecycle.
• Mentor engineers through technical reviews, pairing and architecture discussions.
• Identify opportunities to create reusable engineering patterns, automation, agents or developer tooling.

What We’re Looking For

• 7+ years of software engineering experience building production systems.
• Strong hands-on expertise in C# and .NET / .NET Core.
• Strong system design and architecture skills.
• Experience with distributed systems, APIs, databases, asynchronous processing and cloud-native applications.
• Good understanding of Azure, CI/CD, containers and modern software delivery practices.
• Strong debugging and problem-solving skills.
• Experience using AI coding tools as a meaningful part of day-to-day software engineering.
• Ability to critically review AI-generated code and identify architectural, security or quality issues.
• Strong understanding of software design, testing and engineering best practices.

Nice to Have

• Experience with React / TypeScript.
• Experience in legal-tech, fintech, billing, payments or enterprise SaaS.
• Exposure to AI agents, RAG, MCP or LLM-powered applications.
• Experience building reusable engineering platforms, tooling or automation.
• Familiarity with SOC 2, ISO 27001 or other security/compliance environments.

What Great Looks Like

You can take a complex problem from:

Problem → Design → POC → Architecture → Code → Validation → Production

You know when to rely on engineering judgment, when to challenge the AI, and when to use AI to dramatically accelerate execution.

At Oddr, we are looking for engineers who can think deeply, build quickly and ship safely.

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.

About the client

The client is building a suite of SaaS products for websites—products with clear product-market fit, strong customer pull, and the potential to become $100M+ businesses.

As they grow, they need engineers who go beyond feature delivery. They are looking for backend developers who want to build enduring systems, make practical decisions, and help us ship great products with high velocity.

What You’ll Do

• Work with product, design, and support teams to turn real customer problems into thoughtful, scalable solutions.
• Design and build robust backend systems, services, and APIs that prioritize long-term maintainability and performance.
• Use AI-assisted tooling (where appropriate) to explore solution trees, accelerate development, and reduce toil.
• Improve velocity across the team by building reusable tools, abstractions, and internal workflows—not just shipping isolated features.
• Dig into problems deeply—whether it's debugging a performance issue, streamlining a process, or questioning a product assumption.
• Document your decisions clearly and communicate trade-offs with both technical and non-technical stakeholders.

What Makes You a Strong Fit

• You’ve built and maintained real-world software systems, ideally at meaningful scale or complexity.
• You think in systems and second-order effects—not just in ticket-by-ticket outputs.
• You prefer well-reasoned defaults over overengineering.
• You take ownership—not just of code, but of the outcomes it enables.
• You work cleanly, write clear code, and make life easier for those who come after you.
• You’re curious about the why, not just the what—and you’re comfortable contributing to product discussions

Bonus if You Have Experience With

• Building tools or workflows that accelerate other developers.
• Working with AI coding tools and integrating them meaningfully into your workflow.
• Building for SaaS products, especially those with large user bases or self-serve motions.
• Working in small, fast-moving product teams with a high bar for ownership.

How’s the team?

• Open and flat hierarchy
• High-agency work with a get-stuff-done attitude
• Teams that focus on creating wins - for the org, the team and yourself - all fuelled by mentorship and empowerment

Our Culture

Some values we’ve lived by over these last 14 years:

We think like inventors.

>Invent the answer you wish existed. If it already exists, ask how it could exist better.<

We build for the love of it. And we build the best.

We don’t just copy and paste. We start from first principles—frame the problem, question the default, ship, improve, repeat—until it’s world-class.

Every version and experiment is a chance to push past our comfort zone and hone our craft. It isn’t easy—it takes patience and persistence—but it ends in work we’re proud of.

Ownership builds a rocket ship.

>It’s not the hours you put in your work that count; it’s the work you put in the hours.<

We’re here to build the business. When we see a problem, we own it end‑to‑end. We pull in the right people, ask for help early, track just enough to finish, and close the loop. We focus on what moves the needle, cut low‑impact work, and push hard when it counts—then recover.

That focus builds subject mastery. It helps get in the flow. It fuels passion and can spark healthy friction—and that’s all part of the game. We make a fuss when it matters, and once a call is made, we commit to it fully—whether we all agree or disagree.

Step up to stand tall.

>Greatness is a moving target.<

Chase excellence in your craft and take on bigger problems. Grow into a full-stack problem-solver and leader—whatever your domain. Improve with intent, work with people who push you, and never get too comfortable. That’s how we level up.

Benefits

• Relocation benefits - we’ll book your domestic travel if you are not in Bangalore and help you with 2 weeks of accommodation
• Homemade lunch at the office and a pantry with snacks, fresh coffee & tea
• All the IT essentials and tools you’ll need to be successful in your role, everyone at the office gets an external monitor, ergonomic seating and a mechanical keyboard
• Frequent outings, company-sponsored outdoor events, celebrations for milestones, trips for the entire team and sponsorships to participate at international company events at exotic destinations
• Profit-sharing bonuses based on company growth, tenure and performance
• Paid time off - maternity, paternity, and marriage leave
• Insurance for the whole family

About the job

What you will work on

• Work directly with lenders and lawyers to find what slows them down, then design, test and validate the fix with them.
• Turn direct customer metrics into insights that shape what we build next.
• Architect and scale the document ingestion pipeline so every report gets faster and more reliable as volume grows.
• Find out why LLM output goes wrong, fix it at the root, and build evals that keep it fixed.
• Build out our multi agent system and the tools it uses across government sources.
• Ship features end to end in the web app, and run it on GCP with an eye on cost and latency.

What we are looking for

• 0 to 5 years of experience building and shipping software. Internships, freelance work and serious side projects all count.
• Strong TypeScript and Node.js, with working knowledge of React, SQL and a cloud platform (GCP preferred).
• Hands on experience with LLM APIs: tool calling, structured output and multi agent orchestration, using agent traces and evals to debug and measure them.
• Experience building backend systems that hold up in production: queues, retries, idempotency, and logs and traces to debug them.
• A habit of measuring: you instrument what you ship and let the data decide what to do next.
• Experience integrating with websites and APIs that were never built for you: sessions, form posts, HTML parsing and rate limits.

Nice to have

• Durable workflows and reliable delivery: idempotency keys, the outbox pattern, signed webhooks
• PDF and image processing: OCR and scanned documents
• Reads Hindi, Kannada, Telugu or Tamil
• Exposure to fintech, lending or legal work
• Happy to work from our Gurugram office 5 days a week

Senior Software Engineer I (Backend, Enterprise SaaS - AP) Role summary

•Senior individual contributor owning backend services for a large-scale enterprise SaaS platform (Kanban-style work management and flow).

•Designs and ships features end-to-end, collaborating closely with frontend, product, and QA.

What you’ll do

•Design, implement, and maintain Node.js (TypeScript/JavaScript) backend services and APIs.

•Model and evolve core domain entities (boards, lanes, work items, WIP rules, permissions, cross-team connections).

•Build secure, multi-tenant REST/JSON APIs consumed by web frontends and other internal services.

•Implement business logic for work-flow, metrics, and cross-team visibility.

•Improve performance, reliability, and observability of existing services.

•Integrate backend services with data storage and analytics layers via well-designed interfaces.

•Write and maintain automated tests (unit, integration, contract) and participate in code reviews.

•Partner with product to refine requirements and break work into incremental, shippable slices.

Tech stack

•Node.js, TypeScript/JavaScript

•REST/JSON APIs (GraphQL familiarity a plus)

•Relational/NoSQL data stores

•CI/CD, logging, metrics, and alerting tools

Experience & qualifications

•~6–9 years of backend engineering experience building web or SaaS products.

•Strong Node.js skills and experience designing clean API boundaries.

•Solid understanding of data structures, algorithms, and distributed system basics.

•Experience in agile teams; comfortable collaborating across time zones.

Nice to have

•Experience with Kanban/Agile tools or other developer/productivity SaaS products.

•Experience using AI-assisted coding tools (e.g., GitHub Copilot, Claude Code) in day-to-day development.

•Hands-on experience with React or close collaboration with React frontend teams.

At BigThinkCode, our technology solves complex problems. We are looking for talented back-end (node.JS) engineer to join our at Chennai.

Please find below our job description, if interested apply / reply sharing your profile to connect and discuss.

Company: BigThinkCode Technologies

URL: https://www.bigthinkcode.com/

Experience required: 3-4 years

Work location: Chennai

Joining time: Immediate – 4 weeks

Work Mode: Work from office / Hybrid

Must have skills:

·      Hands on expertise in OOJS, node.js, distributed systems.

·      Event drive architecture (EDA) microservices project experience MUST

·      Any programming: Typescript or nodeJS or Golang

·      Hands on experience using docket containers and Kubernetes.

·      Aware about Asynchronous and Loose Coupling.

·      Familiar with API’s gateway and microservice design patterns.

A skilled Node.js Developer with 5+ years of experience in building scalable applications using event-driven architecture within distributed systems. The ideal candidate should be comfortable in high-performance backend services and have a strong understanding of asynchronous programming patterns.

Experience or exposure to knowledge embedding and vectorization techniques is a strong plus, especially in the context of modern data-driven or AI-powered systems.

Required Skills

·      5+ years of hands-on experience with Node.js

·      Strong understanding of event-driven architecture and non-blocking I/O

·      Experience working with distributed systems and microservices architecture

·      Proficiency in RESTful API design and implementation

·      Experience with databases such as MongoDB, PostgreSQL, or MySQL

·      Experience with containerization tools like Docker and orchestration tools like Kubernetes

Key Responsibilities

·      Design, develop, and maintain server-side applications using Node.js

·      Build and optimize scalable, event-driven systems in distributed environments

·      Implement asynchronous workflows, message queues, and pub/sub architectures

·      Collaborate with cross-functional teams to define and deliver backend solutions

Good to Have 

·      Experience with knowledge embedding and vectorization techniques

·      Familiarity with vector databases (e.g., Pinecone, Weaviate, FAISS)

·      Understanding of cloud platforms (AWS, Azure, or GCP)

Why Join Us:

·      Collaborative work environment.

·      Exposure to modern tools and scalable application architectures.

·      Medical cover for employee and eligible dependents.

·      Tax beneficial salary structure.

·      Comprehensive leave policy

·      Competency development training programs.

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.

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.