Engineering Director

Highradius · Hyderabad

  • Experience14–18 yrs
  • SalaryNot disclosed
  • Work modeonsite
  • Levelexecutive
  • Posted2 Sept 2026
Apply for this job

About Highradius

Highradius is hiring in Hyderabad in technology software. This role looks for around 14+ years of experience.

Skills

  • Python
  • Java
  • Go
  • Node.js
  • Agile
  • Scrum
  • Kanban
  • release management
  • multi-tenancy architecture
  • microservices
  • RESTful APIs
  • AWS
  • Azure
  • GCP
  • CI/CD
  • Docker
  • Kubernetes
  • Terraform
  • CloudFormation
  • PostgreSQL
  • MySQL
  • DynamoDB
  • MongoDB
  • Redis
  • ETL
  • data warehousing
  • event-driven architectures
  • A/B testing
  • OWASP Top 10
  • SSO
  • OAuth2
  • RBAC
  • SCIM
  • SOC 2
  • GDPR
  • HIPAA
  • ISO 27001
  • encryption
  • data residency
  • Datadog
  • New Relic
  • PagerDuty
  • load testing
  • auto-scaling
  • capacity planning
  • technical roadmapping
  • vendor management
  • progressive delivery
  • technical hiring
  • system-design interviews
  • architecture reviews
  • ADRs
  • RFCs
  • tech debt management

The role

An engineering director at a SaaS product company leads software architecture and delivery across multi-tenancy architecture, cloud infrastructure, and application security, guiding platform scalability and technical roadmaps. The role also drives technical hiring and architecture reviews.

Full job description

The core responsibilities for the job include the following:

Software Development Fundamentals:

Programming Proficiency: Strong foundation in at least one backend language (Python, Java, Go, or Node.js ) to review code, unblock teams, and make informed decisions.

Code Review and Quality: Ability to evaluate PRs, enforce coding standards, and identify technical debt.

Software Development Lifecycle (SDLC): Deep understanding of Agile, Scrum, Kanban, and release management processes.

SaaS Architecture and Platform Knowledge:

Multi-Tenancy Architecture: Understanding of tenant isolation, shared vs. dedicated infrastructure, and data partitioning strategies.

Microservices and Monolith: Trade-offs - When to decompose and how to manage service boundaries.

SaaS Metrics: Understanding how technical decisions impact MRR, churn, uptime SLAs, and customer onboarding speed.

API-First Thinking: RESTful APIs, webhooks, third-party integrations, and developer experience (DX).

Cloud and Infrastructure:

Cloud Platforms: Working knowledge of AWS, Azure, or GCP (compute, storage, networking, cost management).

CI/CD and DevOps: Familiarity with deployment pipelines, feature flags, and blue-green/canary deployments.

Containerisation: Docker, Kubernetes, and orchestration strategies.

Infrastructure as Code: Terraform, CloudFormation (enough to guide decisions, not necessarily hands-on daily).

Data and Analytics:

Database Management: Understanding of relational (PostgreSQL, MySQL) and NoSQL (DynamoDB, MongoDB, Redis) trade-offs.

Data Pipelines and Analytics: Familiarity with ETL processes, data warehousing, and event-driven architectures.

Product Analytics: Instrumentation, A/B testing frameworks, and usage tracking.

Security and Compliance:

Application Security: OWASP top 10 secure coding practices and vulnerability management.

Identity and Access: Management SSO, OAuth2 RBAC, and SCIM provisioning (critical in SaaS).

Compliance: Frameworks SOC 2 GDPR, HIPAA, and ISO 27001 (depending on industry).

Data Privacy: Encryption, data residency, and tenant data isolation.

Reliability and Scalability:

Observability: Monitoring, alerting, distributed tracing (Datadog, New Relic, PagerDuty).

Incident Management: On-call rotations, runbooks, post-mortems, and blameless culture.

Performance and Scalability: Load testing, auto-scaling, and capacity planning.

SLA/SLO Management: Defining and tracking uptime commitments (99.9%, 99.99%).

Delivery and Execution:

Technical Roadmapping: Balancing feature development, tech debt, and platform investments.

Estimation and Planning: Breaking epics into deliverables and managing cross-team dependencies.

Build vs. Buy Decisions: Evaluating third-party tools, vendor management, and integration costs.

Feature Flagging and Experimentation: Controlled rollouts, A/B testing, and progressive delivery.

People and Process:

Technical Hiring: Designing system-design interviews, evaluating coding assessments, and calibrating levels.

Architecture Reviews: Leading design reviews, ADRs, and RFCs.

Tech Debt Management: Prioritising refactoring and communicating trade-offs to stakeholders.

Cross-Functional Collaboration: Translating between product, design, and engineering in technical terms.