KubeSense
Website:
kubesense.ai
Job details:
Full Stack Engineer (React + Go/Rust) — Founding Team
Company: KubeSense — Next-Gen Observability Platform with AgentSRE
Location: Chennai, Tamil Nadu (On-site — 5 days a week, no exceptions)
Experience: 3–6 years
Compensation: Well above market standards + meaningful ESOPs (founding team grant)
About KubeSense
KubeSense is an AI-powered observability platform that unifies APM, Logging, Infrastructure Monitoring, and AgentSRE into a single, petabyte-scale system. We're already replacing Datadog, New Relic, and CloudWatch at global companies.
Our tech stack: eBPF and OTel-based proprietary agents, 95% log compression, 40–100× faster queries, AI-driven anomaly detection and root cause analysis, and 100% Bharat-based IP and data residency.
We're small, fast, and building something that matters. You'll be joining the founding team — not a headcount.
What You'll Actually Do
You'll own significant parts of the product — frontend and backend — and ship features that large enterprises depend on in production. This means:
Frontend (React — your primary surface area): Build and own the dashboards, query builders, alerting UIs, log explorers, and AgentSRE interfaces that SREs and DevOps engineers live in all day. Performance, responsiveness, and information density matter here — our users are technical, and they'll notice if your UI is slow or clunky. Think Grafana-level density meets modern design sensibility.
Backend (Go and Rust): Build APIs, data pipelines, query engines, and ingestion services that handle petabytes of telemetry data. Go for services and APIs. Rust for performance-critical components where every millisecond counts.
AI-Augmented Engineering: We expect you to use AI tools — Claude, Cursor, Codex — as daily multipliers. Not as a crutch, but as an accelerator. You write the architecture. You make the design decisions. AI helps you execute faster and catch edge cases. We want engineers who produce well-tested, production-grade code at 10× the speed of someone who doesn't use these tools.
Customer-Facing Impact: You'll interact with engineering teams at our enterprise customers. When something breaks at 2 AM for our customers, you may be the person debugging it. When a customer needs a feature urgently, you may be the one shipping it in 48 hours. This is a high-trust, high-impact role.
What We're Looking For
Technical requirements (non-negotiable):
- 3–6 years of professional software engineering experience
- Strong React.js skills — not just component building, but state management, performance optimization, complex data visualization
- Backend experience in Go (strongly preferred) or Rust. If you know one well and are eager to learn the other, that works.
- Solid understanding of distributed systems, APIs (REST/gRPC), and database design
- Experience writing well-tested code — unit tests, integration tests. "It works on my machine" is not acceptable here.
- Comfortable with Linux, containers (Docker/K8s), CI/CD, and Git workflows
Technical nice-to-haves (will make us very excited):
- Experience with observability tools — Prometheus, Grafana, Jaeger, OpenTelemetry, ELK, Datadog
- Exposure to eBPF, kernel-level instrumentation, or systems programming
- Experience building data-heavy UIs — time series charts, log viewers, trace visualizers
- Familiarity with ClickHouse, TimescaleDB, or similar OLAP/time-series databases
- Open source contributions
Who you are as a person (equally non-negotiable):
- You take ownership. If something is broken, you fix it. You don't wait to be told.
- You're ambitious. You want to build something that matters, not just collect a paycheck.
- You're consistent. You show up every day and deliver. Not in bursts — sustainably.
- You're honest about what you know and what you don't. No pretending.
- You communicate clearly. You can explain a technical decision to a non-technical person and to a kernel engineer with equal clarity.
- You handle pressure well. Startups have crunch moments. You don't crumble — you focus.
- You're curious. You read, you learn, you explore. You don't stop at "it works."
What You Get
- Compensation well above market standards — we don't lowball. If you're good, we'll pay you what you're worth.
- Meaningful ESOPs — you're joining as a founding team member. This isn't a token grant. If KubeSense wins, you win disproportionately.
- Direct founder access — you work with the founders daily. No layers, no middle management.
- Global customer exposure — you'll work with engineering teams at companies doing $100M–$10B+ in revenue. This kind of exposure usually takes a decade to get.
- A team that respects your craft — we care about code quality, architecture, and engineering excellence. We don't ship garbage and call it "moving fast."
How to Apply
Fill out our application form: You figure out how to apply.
We review every application personally. If you're shortlisted, expect a structured process: a technical screen, a take-home problem, a pair programming session, and a founder conversation.
We don't ghost candidates. If it's a no, we'll tell you and tell you why.
Click on Apply to know more.