We are not looking for a maintainer. We are looking for a builder, a fixer, and a leader.

We are seeking an Engineering Lead who thrives on ambiguity and views technology as a tool to solve business problems. You will not be confined to a single tech stack; instead, you will choose the right weapon for the battle. You will take ownership of projects from the "napkin sketch" phase through to deployment, acting as the bridge between business goals and technical execution.

You will be the changemaker —the person who enters a project, identifies the friction points, architects a scalable solution, and leads the team to deliver it with excellence. Key Responsibilities

1. Technical Architecture & Strategy

●            System Design: Architect scalable, secure, and maintainable systems from scratch. You decide whether a project needs a Monolith or Microservices, SQL or NoSQL, Serverless or Containers.

●            Stack Selection: Evaluate and select the appropriate technology stack for each unique project based on trade-offs, scalability, and time-to-market.

●            Code Quality: Set the standard for code reviews, testing frameworks, and documentation. You will code alongside the team to demonstrate patterns and practices.

2. Business-to-Technical Translation

●            Requirement Analysis: Collaborate with stakeholders to deconstruct complex business requirements into actionable technical user stories, database schemas, and API contracts.

●            Feasibility & Risk: identifying technical risks early in the discovery phase and proposing mitigation strategies.

3. Delivery Management & Leadership

●            End-to-End Ownership: Take full accountability for the project lifecycle—from git init to production release.

●            Team Mentorship: Lead developers (frontend, backend, QA) not by authority, but by technical competence. Elevate the team's skills through pair programming and architectural reviews.

●            Process Optimization: Implement or refine CI/CD pipelines, Agile/Scrum methodologies, and deployment strategies to ensure rapid, bug-free delivery.

Required Skill-Set: The Architect’s Toolkit

We are looking for a "Hands-on Architect"—someone who designs the skyscraper but is not afraid to pour the concrete.

I. Advanced System Design & Distributed Architecture

●            Architectural Patterns: Deep command of architectural styles beyond MVC. Expertise in Microservices , Event-Driven Architecture (EDA) , Serverless , and Hexagonal/Clean Architecture . You know exactly when to use a Monolith and when to break it apart.

●            Concurrency & Scalability: Deep understanding of threading, concurrency models (Actor model, CSP), and asynchronous processing. You can design systems that handle massive scale using load balancing, caching strategies (Redis/Memcached/CDN), and horizontal scaling.

●            Distributed Systems Theory: Working knowledge of the CAP Theorem , ACID vs. BASE consistency models, Idempotency, and consensus algorithms (Raft/Paxos). You understand the fallacies of distributed computing.

II. Strategic Technology Leadership (The "Changemaker" Aspect)

●            Tech Stack Governance: Ability to evaluate and select tech stacks based on TCO (Total Cost of Ownership) , developer velocity, community support, and long-term maintainability—not just hype.

●            Modernization Strategies: Proven experience in Legacy Modernization . You know how to migrate a running system without downtime using patterns like the Strangler Fig Pattern or Blue/Green deployments .

●            Technical Debt Management: The ability to quantify technical debt, negotiate "refactoring vs. feature work" with stakeholders, and maintain a healthy codebase over time.

III. Polyglot Persistence & Data Strategy

●            Database Internals: You don’t just write SQL; you understand database internals (B-Trees, LSM Trees, Indexing strategies).

●            Polyglot Persistence: Expertise in designing complex data layers using the right tool for the job—Relational (Postgres/MySQL) for structure, NoSQL (Mongo/Cassandra) for scale, Graph (Neo4j) for relationships, and Search Engines (Elasticsearch) for discovery.

IV. Platform Engineering & Operational Excellence

●            Infrastructure as Code (IaC): Treating infrastructure as software. Proficiency with

Terraform , or CloudFormation . You architect for "Cloud Agnosticism" where possible.

●            Observability (Not just Monitoring): Designing systems that are debuggable in production. moving beyond simple logs to implementing Distributed Tracing (OpenTelemetry, Jaeger), APM, and define clear SLOs/SLAs .

●            DevSecOps: Integrating security into the design phase (Threat Modeling) rather than treating it as an afterthought.

V. Business & Technical Translation

●            Domain-Driven Design (DDD): Expertise in mapping complex business rules into software artifacts (Bounded Contexts, Aggregates, Entities, Value Objects).

●            Stakeholder Negotiation: The ability to explain to a CEO why a feature will take 3 weeks instead of 3 days, and the ability to explain to a Junior Dev why their code needs to change to meet business goals.

The AI-Native Architect

We don't just want you to write code; we want you to conduct the orchestra of AI agents that write the code. You must possess deep expertise in Agentic Workflows and AI-Augmented SDLC .

I. Agentic Architecture & Orchestration (The "BMAD" Standard)

●            Multi-Agent Frameworks: Expert-level knowledge of BMAD (Breakthrough Method of Agile AI-Driven Development) , LangGraph , AutoGen , or CrewAI . You understand how to decompose complex problems into "Agentic Chains" where specialized personas (e.g., an 'AI Architect', 'AI QA', 'AI Product Owner') hand off tasks to one another.

●            Context Engineering: Beyond simple prompt engineering, you know how to architect the Context Window . You can structure project-level knowledge (using Markdown/YAML/Knowledge Graphs) so that agents retain "memory" and "state" across the entire development lifecycle.

●            Spec-Driven Development: You understand that in an AI world, the Specification is the code. You are proficient in writing rigorous PRDs (Product Requirement Documents) and Tech Specs that are optimized for AI consumption, ensuring high-fidelity code generation.

II. "Vibe Coding" at Enterprise Scale

●            Guided Vibe Coding: You practice "Responsible Vibe Coding." You know how to stay in the "flow state" of rapid prototyping using AI (Cursor, Windsurf, Claude Code) while enforcing architectural guardrails. You treat AI code as a junior developer's PR—trusting it but verifying it relentlessly.

●            The "Reviewer-in-Chief" Mindset: Your role shifts from writing syntax to high-velocity code review. You are expert at spotting "AI Hallucinations" , subtle security vulnerabilities, and logic errors that LLMs frequently introduce in complex loops.

●            Tool Use & Function Calling: You know how to build agents that don't just talk but do . You have experience implementing Tool Use (Function Calling) capabilities, allowing agents to execute SQL queries, run tests, or trigger deployments autonomously.

III. Adaptive System Design (Polyglot & Agnostic)

●            Stack Agnosticism via AI: You are not limited by language syntax because you use AI to bridge gaps. You can architect a solution in Rust for performance or Python for data, even if you haven't written them daily, by leveraging Agentic assistance for syntax correctness.

●            Distributed Systems Knowledge: You understand the CAP theorem, Event-Driven Architecture, and Microservices patterns. You ensure that the code your agents generate fits into a clean, scalable Hexagonal or Clean Architecture , preventing the "Big Ball of Mud" that unchecked AI coding can create.