Product Engineer · Office-first (Bangalore) · Engineering

Base14; Bengaluru; On-site; INR 900,000 - 1,300,000; Full time

Job summary

Base14 is building Scout, an observability platform on OpenTelemetry for logs, metrics, traces, APM and RUM. We hire Product Engineers to ship features end to end across UI, services and infra.

You will own features from the first problem discussion to production health dashboards, deploying via GitOps and instrumenting with OpenTelemetry. This role targets 2–4 years of distributed-product experience, with full-stack ability in TS/React and backend in Go/Rust/Python/TS, plus a strong sense of

Qualifications

• 2-4 years building and operating distributed products.
• Full-stack: TypeScript/React frontend and backend in Go, Rust, Python or TS.
• Strong understanding of queues, APIs, data stores and caches.
• Experience debugging live issues with logs, metrics and traces.
• Ability to ship clean, fast code and own features end-to-end.
• Familiarity with AI-assisted development and automation.

Responsibilities

• Own features end to end from problem framing to production dashboard.
• Build distributed services and data pipelines for real-time telemetry.
• Deploy through GitOps, instrument services and set up alerts.
• Own the infrastructure under features, defining Kubernetes workloads and cloud resources.
• Develop agents and AI-powered capabilities that operate in production.
• Maintain fast interface response times as data volume grows.
• Engage with customers to understand problems and guide product decisions.
• Automate workflow using AI assistants and tooling.

Skills

2-4 years distributed products

Full-stack TypeScript/React

Go / Rust / Python / TS backend

Distributed systems fundamentals

Production ownership

AI-assisted execution

Ambiguity tolerance

Tools

React

TypeScript

Next.js

Tailwind

WebSockets

SSE

Go

Rust

Python

Kafka

gRPC

OpenTelemetry

Kubernetes

GitOps

Argo CD

AWS / GCP / Azure

Job description

We are building autonomous infrastructure.

base14 builds Scout, an observability platform built on OpenTelemetry that covers logs, metrics, traces, APM and RUM. On top of that telemetry, we are building agents that manage production infrastructure. Self-healing, autonomous infrastructure is a company goal.

We are hiring Product Engineers who build features end to end and run them in production. You will work across the interface, the backend services and the infrastructure underneath them.

The Role

You will own product features from the first conversation about the problem to the dashboard that tells you the feature is healthy in production. That covers the React interface, the service behind it, the data it reads, and the deployment it runs on.

You run what you ship. You deploy it through GitOps, instrument it with OpenTelemetry, watch it in Scout, and fix it when it breaks. Engineers here own their infrastructure along with their code, and we want people who find that appealing.

This role suits someone with 2 to 4 years of experience who has already built and operated a distributed product and wants more ownership than they have today.

We expect you to automate your own workflow. You will use AI tools and LLMs to write code, generate tests, build interfaces and debug production issues, so you can focus on hard technical and product problems.

What You'll Do

• Own features end to end: Design, build and ship features across the stack, from the React interface to the backend services and the data behind them.
• Build distributed services: Write services and data pipelines that handle real-time telemetry. Design for retries, partial failures and outages from the start.
• Run what you build: Deploy through GitOps, instrument your services, set up alerts, and share on-call for the services you own.
• Own the infrastructure under your features: Define the Kubernetes workloads, cloud resources and delivery pipelines your services need, as code, across AWS, GCP and Azure.
• Build toward autonomous infrastructure: Work on the features that bring our agents into the product, from how they use telemetry to how engineers review and trust what the agents do.
• Keep it fast: Hold sub-second response times in the interface and the APIs as data volume grows.
• Work with customers: Talk to founders and customers, understand the problem, and make the product decisions inside your features.
• Automate your work: Use AI assistants and automation tools to write, test and debug code.

What We Look For

Must Have

• 2 to 4 years building and operating distributed products: You have shipped features in a product made of multiple services, and you have been responsible for them in production.
• Full-stack ability: You are productive in TypeScript and React on the frontend and in at least one of Go, Rust, Python or TypeScript on the backend. You are willing to pick up the others.
• Distributed systems fundamentals: You understand queues, APIs, data stores and caches, and you know what happens to the product when one of them fails.
• Production ownership: You have debugged live issues using logs, metrics and traces, and you have shipped the fix yourself.
• Craft: You write clean, legible and fast code, and you care about how the product feels to use.
• AI-assisted execution: You use generative AI tools to write code faster and to handle routine engineering tasks.
• Comfort with ambiguity: You work well with changing requirements and make progress without a detailed spec.

Strong Pluses

• Infrastructure ownership: You have owned the infrastructure for a product you worked on, including Kubernetes, infrastructure as code, CI/CD or GitOps, and cloud networking and cost. This is a huge bonus for us.
• Agent-building experience: You have built AI agents or LLM-driven features that run in production.
• Observability or developer tools background: You have built, or been a demanding user of, observability and developer tools.
• Data-heavy products: You have built user-facing features on ClickHouse or another analytical database.

Technical Stack

• Frontend: React, TypeScript, Next.js, Tailwind, real-time updates over WebSockets and SSE
• Backend: Go, Rust, TypeScript and Python, with Ruby in places
• Distributed Systems: Microservices, Kafka, gRPC, OpenTelemetry
• Infrastructure: Managed Kubernetes on AWS, GCP and Azure. Talos Linux on VMs in our data centers.
• Delivery: Argo CD, GitOps, 100% automated infrastructure
• AI & Automation: LLM APIs (OpenAI, Anthropic, Gemini), agent tooling, AI coding assistants

Why Join Us

• Build autonomous infrastructure: We are building agents that read telemetry and manage production systems on their own. You will build the product that puts them in engineers' hands.
• Full ownership early in your career: You own features from idea to production, including the infrastructure. Few roles at this experience level offer that range.
• Equity: Every employee owns a stake in the company.
• Strong peers: You will learn from engineers who have scaled massive infrastructure.
• Fast feedback: Your work reaches customers within days of shipping.
• Room to grow: The team is small and growing. As it grows, you can take on larger parts of the product and the team.

What We Offer

• Competitive salary and equity.
• Collaboration with experienced founders.
• Hardware and software of your choice, including premium AI development tools.
• Learning budgets and flexible hours focused on work output.