Principal Engineer - Backend

Responsibilities:

• Microservices Architecture Enhancement:
• Scalability Enhancement: Elevate microservices architecture to the next level of scalability, ensuring optimal performance in diverse scenarios.
• Efficiency Optimization: Streamline and enhance the efficiency of microservices, exploring innovative solutions for resource optimization.
• Observability Implementation: Implement robust observability mechanisms, enabling comprehensive monitoring and diagnostics.
• Availability Enhancement: Improve the availability of microservices, ensuring reliability even in high-demand scenarios.
• Multi-Region and Multi-Cloud Deployment:
• Cross-Region Systems: Build, deploy, and run multi-homed systems designed to operate seamlessly across multiple regions.
• Cloud Provider Flexibility: Develop systems that function across various cloud providers, enhancing flexibility and minimizing dependencies.
• Petabyte-Scale Data Processing:
• Data Processing Systems: Design and open-source data processing, storage, and retrieval systems at the petabyte scale.
• Cost-Effective Scaling: Ensure scalability while maintaining the lowest cost per gigabyte, responding rapidly even at the 99th percentile.
• Platform and Library Development:
• Platform Creation: Develop platforms, reusable libraries, and utilities to enhance the efficiency and consistency of development efforts.
• Open Source Initiatives: Contribute to open-source projects, sharing innovations and solutions with the broader community.
• Code Quality and Best Practices:
• High-Quality Code: Write high-quality, modular, functional, and testable code to drive the reliability of microservices.
• Coding Standards: Establish and promote the adoption of the best coding practices within the development team.
Decision-Making Authority:
• Strategic Decision-Making: Exercise strong decision-making abilities, particularly in matters related to architecture, scalability, and efficiency.

Skills:

• Deep Understanding of Java
• Core Library/Language Constructs: To excel in this role, you should possess a deep understanding of Java. This includes proficiency in core language constructs, object-oriented programming principles, and advanced topics such as concurrency, memory management, and compiler optimizations.
• Knowledge of System Internals
• Processor, Memory, Network, and Storage Internals: Understanding the internals of processors, memory, networks, and storage devices is essential for optimizing code performance and resource utilization. This knowledge enables developers to write code that takes advantage of hardware capabilities and avoids potential bottlenecks.
• Familiarity with I/O Optimized Algorithms
• I/O Optimized Algorithms: I/O operations are often a bottleneck in performance-critical applications. Familiarity with I/O optimized algorithms, such as asynchronous I/O, non-blocking I/O, and direct memory access (DMA), is essential for minimizing I/O overhead and achieving high throughput.
• Deep Understanding of Distributed Systems
• Fault Modeling, Concurrency, Isolation, Consensus: Distributed systems pose unique challenges due to their decentralized nature. A deep understanding of fault modeling, concurrency, isolation, and consensus algorithms is crucial for building reliable and scalable distributed applications.
• Dynamo, HBase, Messaging Systems, Time, Clocks, Ordering of Events, Rate Control, Load Distribution: Studying distributed systems
• Design and Problem-Solving Skills: Great design and problem-solving skills with a strong basis for architecting performance, scalability, security, and reliability are essential for building high-quality software systems.
• Conversant with the Internals of Systems
• Kafka, Cassandra/Scylla, Redis: Familiarity with the internals of popular distributed systems like Kafka, Cassandra/Scylla, and Redis is essential for troubleshooting issues, optimizing performance, and making informed decisions about their usage.
• Working Knowledge of Hosting and Network Infrastructure (K8s)
• Kubernetes (K8s): Kubernetes is a leading container orchestration platform for managing and deploying containerized applications. Working knowledge of K8s is essential for building and deploying cloud-native applications.
• Familiarity with Low-Level Network Protocols
• gRPC, HTTP/2, QUIC: Familiarity with low-level network protocols like gRPC, HTTP/2, and QUIC is beneficial for understanding the underlying mechanisms of network communication and optimizing application performance.
• Troubleshooting and Performance Optimization
• Memory Issues, GC Tuning, Resource Leaks: Troubleshooting memory issues, GC tuning, and resource leaks is critical for maintaining application stability and performance. Expertise in these areas is essential for ensuring efficient resource utilization and preventing performance degradation.
• Understanding of Branching, Build, Deployment, CI/CD Methodologies
• Branching, Build, Deployment, CI/CD: A good understanding of branching strategies, build tools, deployment processes, and continuous integration/continuous delivery (CI/CD) methodologies is crucial for streamlining software development and ensuring rapid delivery of high-quality software.
• Deep Understanding of OOAD and Algorithms
• OOAD and Efficient Data Structures: A deep understanding of object-oriented analysis and design (OOAD) principles and efficient data structures is crucial for designing well-structured, maintainable, and performant software systems.
• Cloud Technologies
• AWS/Google Cloud, Azure, OpenStack: Having knowledge of cloud technologies like AWS/Google Cloud, Azure, and OpenStack is beneficial for understanding cloud infrastructure and leveraging cloud services effectively.

Experience and Qualifications:

• 8-10 years of experience in software development and delivery.
• Experience in Java, Spring, REST, SQL (PostgreSQL or MYSQL) Messaging systems, ELK stack, and microservices is required.
• Engineering degree in computer science or equivalent.