Endura Security is hiring a Backend Engineer to help build Team Server, the control plane behind our runtime security platform. You will design and implement the Rust services, REST APIs, integrations, and data systems that connect Runtime Sensors with the teams responsible for securing modern CI/CD environments.
This is backend engineering for a security product with real operational consequences. The systems you build will ingest runtime activity, manage pipelines and policies, surface violations, integrate with external platforms, and give security teams the context they need to act.
About the role
You will work on Team Server, the backend platform that centralizes pipeline discovery, runtime telemetry, security policies, violations, and integrations across Endura deployments.
This is a high-ownership role covering API design, domain modeling, data ingestion, authentication and authorization, integration development, performance, and reliability. You will work closely with engineers building Runtime Sensor and other parts of the platform to evolve the protocols and APIs connecting Endura's distributed components.
The backend is primarily written in Rust, and we value engineers who care about correctness, maintainability, explicit behavior, and thoughtful API design.
What you will do
- Design, build, and maintain backend services primarily in Rust.
- Develop REST APIs used by the Endura frontend, Runtime Sensors, integrations, and external systems.
- Build reliable ingestion paths for runtime events, pipeline activity, violations, and other security telemetry.
- Design domain models for pipelines, builds, policies, violations, deployments, users, and related platform concepts.
- Build integrations with CI/CD platforms, notification systems, identity providers, and other developer infrastructure.
- Implement authentication, authorization, and granular access controls for security-sensitive operations.
- Build policy-management workflows that support deriving, reviewing, assigning, and enforcing security policy.
- Develop APIs and workflows for violation triage, investigation, notifications, and response.
- Improve database schemas, queries, indexing, and data-access patterns as the platform grows.
- Design asynchronous and event-driven workflows for tasks that should not block interactive API requests.
- Build backend capabilities that work across both managed and customer self-hosted deployments.
- Improve observability through structured logging, metrics, tracing, and actionable diagnostics.
- Write automated tests across unit, integration, and end-to-end boundaries.
- Investigate difficult production issues across application, database, API, networking, and integration layers.
- Participate in architecture decisions and help establish backend engineering standards as the product evolves.
What we are looking for
- 4+ years of backend or systems engineering experience building production software.
- Strong proficiency in Rust, or substantial experience in another systems-oriented language with the ability to become productive in Rust quickly.
- Experience designing and maintaining production REST APIs.
- Strong understanding of relational data modeling, transactions, indexing, and query performance.
- Experience designing APIs and services around complex domain models and state transitions.
- Familiarity with asynchronous programming, concurrency, and reliable background processing.
- Experience integrating with third-party APIs, webhooks, authentication systems, or developer platforms.
- Strong understanding of authentication, authorization, secrets handling, and secure backend development.
- Ability to reason carefully about failure modes, retries, idempotency, consistency, and partial failure.
- Strong debugging skills and the ability to investigate problems across multiple layers of a distributed system.
- A preference for clear, maintainable designs over unnecessary abstraction or complexity.
- Comfort working independently in a small engineering organization where engineers own significant portions of the product.
Beneficial skills to have
- Deep experience with Rust and its async ecosystem.
- Experience building security products, developer tools, or infrastructure software.
- Familiarity with CI/CD platforms such as GitHub Actions, GitLab CI/CD, Jenkins, TeamCity, Bamboo, or similar systems.
- Experience building webhook, OAuth, OIDC, or identity-provider integrations.
- Experience with role-based and resource-level authorization models.
- Experience designing high-volume telemetry or event-ingestion systems.
- Familiarity with Linux, containers, Kubernetes, and self-hosted enterprise software.
- Experience with PostgreSQL or another production relational database.
- Knowledge of application security, software supply chain security, or CI/CD security.
- Familiarity with eBPF, Linux security concepts, or runtime security.
- Experience designing APIs consumed by agents, sensors, or other distributed endpoint software.
- Experience supporting both SaaS and customer-managed deployment models.
What you will get
- Significant ownership over Team Server architecture and backend engineering decisions.
- The opportunity to build a security platform in Rust from the core outward.
- Direct influence over APIs, domain models, integrations, and workflows that define how customers operate Endura.
- Interesting distributed-systems problems connecting kernel-level Runtime Sensors with centralized policy and response workflows.
- A small engineering environment with minimal bureaucracy and a high degree of technical autonomy.
- Close collaboration with engineers working across Linux, eBPF, CI/CD, frontend systems, infrastructure, and security policy.
- The opportunity to help establish engineering practices and technical direction while the platform is still evolving.
Why join our team
Endura is building a software supply chain security platform around a simple idea: knowing what software is does not give you control over what it does.
Runtime Sensors enforce security boundaries where software executes. Team Server turns that distributed runtime activity into something security and engineering teams can actually operate: centralized pipeline visibility, policy management, violations, integrations, access control, and response.
As a Backend Engineer, you will build the systems connecting those pieces. The work spans security, distributed systems, APIs, data modeling, developer infrastructure, and systems software rather than another conventional CRUD application.
If you enjoy Rust, thoughtful backend architecture, complex domain problems, and building infrastructure that developers and security teams depend on, you will have meaningful ownership here.
