Zocket Technologies Private Limited

About Zocket

Zocket is building the AI-native operating system for enterprise brand marketing. Our platform is powered by a multi-agent AI architecture where specialized agents handle creative generation, brand compliance, competitive intelligence, and campaign optimization — all coordinated through a proprietary brand knowledge graph built on Neo4j. We serve enterprises like Lenovo and Bata across multiple markets, and we’re solving hard problems at the intersection of agentic AI, knowledge representation, and multimodal content generation.
The founding team built and scaled a performance marketing company (GoBumpr) managing large ad budgets before starting Zocket. We’re not theorists — we built this because we lived the pain of brand marketing at scale.

The Technical Landscape

This is what you’ll be working with and building on:

AI & Agent Systems

  • Multi-Agent Orchestration: A fleet of specialized AI agents (creative generation, compliance checking, competitive analysis, campaign intelligence) that coordinate, share context, and produce coherent outputs. We’re working with agentic frameworks and building custom orchestration layers for enterprise-scale reliability.
  • Brand Knowledge Graph (Neo4j): A proprietary knowledge graph capturing brand identity, guidelines, competitive positioning, market context, and campaign performance history. This graph is the shared memory and reasoning substrate for all agents.
  • Context & Memory Layers: Short-term working memory for task execution, long-term memory for brand knowledge persistence, and retrieval mechanisms (RAG + graph traversal) that give agents the right context at the right time.
  • Multimodal Brand Compliance: Validating generated content (text, image, video) against brand rules encoded in the knowledge graph, with feedback loops for continuous improvement.
  • Video Generation & Consistency: Working with models like Google Veo for video generation, maintaining brand-consistent visual identity, scene coherence, and style continuity.
  • AI Evals & Agent Monitoring: Evaluation pipelines for measuring agent output quality, brand compliance accuracy, hallucination rates, and task completion reliability. Continuous monitoring of agent behaviour in production with alerting, drift detection, and regression tracking across prompt and model changes.

Backend & Infrastructure

  • API & Services Architecture: RESTful and event-driven microservices handling authentication, authorization, rate limiting, request validation, error handling, and graceful degradation. Clean API contracts between services, versioning strategies, and backward compatibility for enterprise clients.
  • Real-Time Systems: WebSocket services for live Brand Intel Dashboard updates, agent status streaming, and collaborative features. Connection management, fan-out patterns, and graceful degradation at scale.
  • Event-Driven Pipeline: Kafka for agent event streaming, async task processing, cross-service communication, and audit logging. Topic design, partitioning strategies, consumer group patterns, and delivery guarantees.
  • Caching & State Management: Redis for agent context caching, session state, rate limiting, pub/sub for real-time features, and distributed locking for concurrent agent operations.
  • Data Layer: PostgreSQL as the relational backbone for transactional data, user management, and campaign state. Neo4j for the knowledge graph. OLAP databases (ClickHouse / Lighthouse) for analytics workloads powering the Brand Intel Dashboard — aggregations over millions of ad performance records, competitive benchmarks, and trend analysis.
  • Data Collection Infrastructure: Web scraping (Apify, Crawlee), official API integrations, data normalization, and ingestion pipelines feeding both Neo4j and the OLAP layer.

DevOps, CI/CD & Infrastructure

  • Containerization & Orchestration: Docker for service packaging, Kubernetes for orchestration, scaling, and service mesh. Infrastructure-as-Code (Terraform / Pulumi) for reproducible deployments.
  • CI/CD Pipelines: Automated build, test, lint, security scan, and deployment workflows. GitOps-based deployment strategies with staged rollouts, canary deployments, and automated rollback for production safety.
  • Observability Stack: Centralized logging, distributed tracing (OpenTelemetry), metrics collection (Prometheus/Grafana), and alerting. Full-stack visibility from API latency to Kafka consumer lag to LLM call performance to agent pipeline traces.
  • Cloud Infrastructure: AWS-based infrastructure with cost-aware architecture. VPC design, IAM, secrets management, and security posture appropriate for enterprise clients handling sensitive brand data.

Stack Summary

  • Frontend: Next.js, React, Tailwind CSS
  • Backend: Python, Node.js, WebSockets, REST APIs
  • Databases: PostgreSQL, Neo4j (knowledge graph), ClickHouse (OLAP/analytics), Redis (caching/state)
  • Streaming & Messaging: Kafka
  • AI/LLM: Anthropic Claude, Google Gemini/Veo, RAG pipelines, custom agent orchestration
  • Infrastructure: AWS, Docker, Kubernetes, Terraform
  • CI/CD & Observability: GitHub Actions, ArgoCD, Prometheus, Grafana, OpenTelemetry
  • Project & Communication: Linear, Slack

How We Build: Autonomous AI-Native Engineering

This is not a team that uses AI as an autocomplete. We’re building toward an engineering model where engineers operate as technical leads over teams of autonomous coding agents. Here’s what that looks like in practice:
  • Spec-Driven Autonomous Development: Engineers write precise specs and agent frameworks (OpenSpec, Speckit, BMAD, and similar tools) execute the implementation autonomously. The engineer’s job shifts from writing every line of code to defining intent, reviewing agent output, and ensuring quality.
  • Linear + Slack as the Coordination Layer: Standardized on Linear for project management and Slack for communication, integrated tightly so that specs, agent outputs, reviews, and deployments flow through a unified pipeline.
  • Coding Agent Orchestration: Engineers manage multiple coding agents working in parallel — decomposing work into agent-executable tasks, defining acceptance criteria, reviewing agent-generated PRs, and maintaining system coherence.
  • Human-in-the-Loop Quality Gates: Agents build, engineers validate. The engineer’s role evolves toward architectural judgment, system design, edge case identification, and ensuring agent output meets enterprise-grade quality.
  • Continuous Evolution: The tooling landscape is changing fast. We expect the Head of Engineering to continuously evaluate new agent frameworks, refine autonomous development workflows, and push the boundary of what a small team can ship.

The Role

We don’t believe in engineering managers who only manage people and processes. At Zocket, the Head of Engineering is a hands-on technical leader who architects systems, defines specs, reviews agent output, and mentors engineers — while setting the engineering culture and ensuring the team ships with velocity and quality. You’re not managing a team the traditional way. You’re building the systems and culture where a small team of engineers, each leading a squad of coding agents, can out-ship teams 5x their size.

What You’ll Own

Agent Architecture & Knowledge Systems

  • Own the end-to-end architecture of the multi-agent platform: agent design, inter-agent communication protocols, task decomposition, error recovery, and orchestration patterns.
  • Design and evolve the context and memory layer — how agents accumulate, persist, retrieve, and reason over knowledge. This includes RAG pipelines, graph-based retrieval from Neo4j, context window management, and session memory strategies.
  • Architect the brand knowledge graph schema and query patterns in Neo4j. Define how brand identity, guidelines, competitive intelligence, and campaign history are represented as graph relationships and how agents traverse them.
  • Build the multimodal compliance engine: validate generated text, images, and video against brand rules encoded in the knowledge graph, with feedback loops for continuous improvement.
  • Make build-vs-integrate decisions on agentic frameworks (LangGraph, CrewAI, Autogen, custom) and foundational AI capabilities (LLM routing, embedding models, video generation, voice synthesis).

AI Evals, Testing & Agent Monitoring

  • Design and build the evaluation pipeline for AI agents: automated evals for brand compliance accuracy, creative quality, hallucination detection, and task completion rates. Define what “good” looks like for each agent and how to measure it quantitatively.
  • Build regression testing infrastructure for prompt and model changes. When a prompt is updated or a model version changes, you need to know what broke before it hits production.
  • Own production monitoring for the agent layer: real-time tracking of agent success/failure rates, latency distributions, cost per task, output quality scores, and drift detection over time.
  • Design A/B testing and experimentation frameworks for agent configurations — different prompts, model versions, retrieval strategies, or orchestration patterns — with measurable outcomes tied to business metrics.
  • Build feedback loops between agent monitoring data and the knowledge graph, so agent performance insights feed back into improved brand representations and retrieval strategies.

Backend Infrastructure & Platform Engineering

  • Design and own the core backend architecture: API design (REST, GraphQL where appropriate), service boundaries, inter-service contracts, authentication/authorization (OAuth, API keys, RBAC for enterprise multi-tenancy), request validation, error handling, and graceful degradation.
  • Architect the real-time infrastructure: WebSocket services for live dashboard updates, agent status streaming, and collaborative features. Connection management, heartbeats, reconnection strategies, and fan-out at scale.
  • Own the event-driven pipeline: Kafka for agent event streaming, async task processing, cross-service communication, and audit logging. Topic design, partitioning, consumer group patterns, dead letter queues, and exactly-once semantics where it matters.
  • Design the caching and state management layer: Redis for agent context caching, session state, rate limiting, pub/sub, and distributed locking for concurrent agent operations.
  • Architect the data layer across multiple database paradigms: PostgreSQL for transactional data and campaign state (schema design, migrations, query optimization, connection pooling), Neo4j for the knowledge graph (graph schema, Cypher query performance, traversal patterns), and ClickHouse/Lighthouse for OLAP workloads (materialized views, aggregation pipelines, query performance for the Brand Intel Dashboard).
  • Own database performance, schema evolution, and data modeling across all three paradigms. The Brand Intel Dashboard aggregates millions of records for enterprise clients — query performance is not optional.

DevOps, CI/CD & Production Reliability

  • Own the CI/CD pipeline end-to-end: automated builds, test suites (unit, integration, e2e), linting, security scanning, container image builds, and deployment automation. GitOps-based workflows with staged rollouts and automated rollback.
  • Design the deployment strategy: containerized services on Kubernetes, infrastructure-as-code (Terraform/Pulumi), environment parity (dev/staging/prod), secrets management, and reproducible deployments.
  • Build and maintain the observability stack: centralized logging, distributed tracing (OpenTelemetry), metrics dashboards (Prometheus/Grafana), and alerting. Full-stack visibility from API response times to Kafka consumer lag to PostgreSQL query performance to LLM API latency to agent pipeline traces.
  • Own production reliability: SLA management for enterprise clients, incident response processes, post-mortems, capacity planning, and cost optimization across AWS infrastructure, database clusters, and LLM API spend.
  • Ensure security posture appropriate for enterprise clients: vulnerability scanning, dependency management, network security, data encryption at rest and in transit, and compliance with enterprise data handling requirements.

Autonomous Engineering Infrastructure

  • Design and operationalize the spec-to-deployment pipeline: how specs written in Linear flow through coding agent frameworks (OpenSpec, Speckit, BMAD) into reviewed, tested, and deployed code.
  • Evaluate, integrate, and evolve coding agent frameworks as the tooling landscape matures. Define which classes of work are agent-executable today versus where engineers need to be hands-on.
  • Build the quality and review infrastructure around autonomous development: automated checks, agent output validation, test generation, and human-in-the-loop review workflows.
  • Set up the Linear + Slack integration architecture so that project management, agent execution, code review, and deployment form a coherent, low-friction pipeline.

Data & Intelligence Pipeline

  • Own the data collection architecture: web scraping infrastructure (Apify, Crawlee, hybrid approaches with official APIs), data normalization, and ingestion into Neo4j and ClickHouse.
  • Ensure the Brand Intel Dashboard is powered by reliable, fresh, and auditable data pipelines that enterprise clients can trust.
  • Design the competitive intelligence workflows that feed both the dashboard and agent reasoning — from raw data collection to structured insights in the knowledge graph.

Team Leadership & Engineering Culture

  • Mentor and grow the engineering team. Raise the technical ceiling of everyone around you through pairing on hard problems, deep spec reviews, architecture discussions, and teaching engineers how to think about system design at every layer — from database schema design to agent orchestration.
  • Define and evolve the engineering culture and playbook. We have an existing engineering mantra focused on ownership, customer-first thinking, and AI-assisted workflows. Your job is to take it to the next level — encoding how engineers reason about multi-agent systems, backend reliability, knowledge graph design, and autonomous development workflows.
  • Train engineers to operate as technical leads over coding agents: writing precise specs, decomposing work for agent execution, reviewing agent output critically, and maintaining system coherence across both AI and infrastructure layers.
  • Hire engineers who can thrive in an AI-native, agent-driven engineering environment. You’ll have a direct say in every engineering hire.

Product & Enterprise Delivery

  • Partner with the founding team to translate product vision into technical execution across Zocket’s core surfaces: Brand Intel Dashboard, AI creative tools, and the compliance engine.
  • Own delivery for enterprise clients. Understand the gap between a working demo and a production-grade system that a Lenovo or Bata can rely on — reliability, auditability, data governance, and SLAs.
  • Drive observability across the full stack: LLM call monitoring, agent pipeline tracing, Kafka consumer lag, PostgreSQL query performance, Redis hit rates, WebSocket connection health, OLAP query latency, and CI/CD pipeline health. Enterprise clients expect dashboards that load fast and data that’s fresh.
  • Own cost management across the infrastructure: LLM API spend, database scaling costs, Kafka cluster sizing, AWS infrastructure, and the tradeoffs between performance and cost at each layer.

What We’re Looking For

Must-Haves

  • 8+ years of software engineering experience, with at least 2–3 years building AI/ML-powered products in production (not research, not prototyping — production systems with real users).
  • Strong backend engineering fundamentals: you’ve designed and scaled production systems with microservices architectures, event-driven patterns (Kafka), real-time capabilities (WebSockets), caching layers (Redis), and relational databases (PostgreSQL). You have strong opinions on API design, auth patterns, error handling, and service boundaries.
  • Experience working across multiple database paradigms in production: relational (PostgreSQL), graph (Neo4j or similar), and columnar/OLAP (ClickHouse, BigQuery, or similar). Strong instincts on data modeling, query optimization, indexing strategies, and when to use which database for which workload.
  • Deep hands-on experience with agentic AI systems: multi-agent orchestration, agent memory and context management, tool use, or agentic frameworks (LangGraph, CrewAI, Autogen, or custom orchestration layers).
  • Working experience with graph databases, preferably Neo4j. Comfortable designing graph schemas, writing Cypher queries, and reasoning about when graph-based retrieval beats vector search or relational joins.
  • Strong understanding of LLM-based systems: prompt engineering, RAG architectures, embedding pipelines, model routing, context window optimization, and the tradeoffs between different LLM providers.
  • Experience building AI evaluation and monitoring systems: automated evals for output quality, regression testing for prompt/model changes, and production monitoring of AI system behaviour.
  • DevOps and CI/CD experience: you’ve built or significantly improved deployment pipelines, worked with containerized environments (Docker/Kubernetes), infrastructure-as-code, and production observability (logging, tracing, metrics, alerting).
  • Proven track record of mentoring engineers. You’ve changed how someone thinks about a problem, not just solved it for them.
  • Systems engineering depth: you understand distributed systems, async pipelines, connection pooling, backpressure, failover strategies, and the messy reality of AI in production (latency, cost, non-determinism, failures).
  • Fluency with AI-assisted and agent-driven development workflows. You should already be using coding agents (Cursor, Claude Code, or similar) in your daily work and have opinions on spec-driven autonomous development.

Strong Signals

  • Experience with autonomous coding agent frameworks (OpenSpec, Speckit, BMAD, or similar spec-to-code pipelines). If you’ve built or evaluated these systems, we want to talk.
  • Experience designing and operating knowledge graphs for AI reasoning — not just storage, but as an active substrate for agent decision-making.
  • Experience building real-time systems at scale: WebSocket architectures with thousands of concurrent connections, Kafka pipelines processing high-throughput event streams, or Redis-backed distributed state systems.
  • Hands-on experience with OLAP/analytics databases (ClickHouse, BigQuery, Druid) for building customer-facing analytics dashboards over large datasets.
  • Experience building AI eval frameworks: custom evaluation harnesses, prompt regression suites, or production quality monitoring for LLM-based systems.
  • Familiarity with multimodal AI: vision models, video generation (Veo, Runway, Sora), or compliance/validation systems over multimodal outputs.
  • Experience with the enterprise AI stack: Anthropic Claude API, Google Vertex AI / Gemini, AWS Bedrock. Understanding of API compliance, rate limiting, cost management at scale.
  • Strong DevOps background: Kubernetes cluster management, Terraform/Pulumi at scale, GitOps workflows (ArgoCD/Flux), and production incident management for enterprise SLAs.
  • Background in brand/marketing tech, ad platforms, creative generation, or competitive intelligence.
  • Contributions to open-source AI tooling, infrastructure projects, or published technical writing on agent architectures, backend systems, or knowledge graphs.
  • Startup experience — you’ve operated where you wore multiple hats and shipped fast with a small team. Bonus if you’ve sold to or worked with enterprise clients.

What You Won’t Be Doing

  • Sitting in meetings all day. You’ll be in the architecture, in the graph schema, in the agent traces, in the Kafka topic configs, and in the spec reviews.
  • Writing performance reviews as your primary contribution. Mentorship here means pairing on agent orchestration bugs, reviewing graph query performance, debugging Kafka consumer lag, and teaching engineers how to write specs that agents can execute reliably.
  • Managing a team the old way. There are no standups-for-the-sake-of-standups here. Engineers manage coding agents. Your job is to build the systems, workflows, and culture that make that model productive.
  • Babysitting a legacy stack. Everything we build is AI-native from the ground up. You’re not modernizing — you’re pioneering.

Why Zocket

  • Founding-level impact. You’re shaping the technical DNA of the company, not joining a mature org where the architecture is already decided.
  • Full-stack ownership. From Kafka topic design to Neo4j graph schemas to agent eval pipelines to CI/CD — you own the entire engineering surface.
  • Genuinely hard problems. Multi-agent orchestration over a knowledge graph, multimodal brand compliance, video generation consistency, real-time analytics at scale — these are frontier challenges with paying enterprise customers.
  • A new way to build software. We’re not just using AI in our product — we’re building an engineering model where small teams with coding agents out-ship traditional teams 5x their size. You’ll define how that works.
  • A founding team that gets it. We built and scaled a performance marketing company. We understand the domain, have real customer relationships, and know the difference between a demo and a product.
  • AI-native from day one. The entire stack, product, and team culture is built around AI — from the multi-agent platform to how we write code.


View all job openings