Founding Engineer

At Deepgrids, we’re building coordination infrastructure for enterprise operations, starting with the deal lifecycle.

Enterprise deals don’t fail because the product is wrong or the pricing is off. They fail in the spaces between teams. A multi-million dollar opportunity stalls because Legal is waiting on a security assessment completed weeks ago, but nobody connected the dots. The information exists; it’s scattered across CRM records, Slack threads, email chains, and the memories of people who don’t know what they know is critical.

Deepgrids is a coordination layer that sits between the systems organizations already use, maintaining real-time process state, learning patterns from execution history, and orchestrating action through AI agents. Rather than replacing CRM, CPQ, or CLM, we hold the relational context none of them captures.

We’re pre-product with funding in place, building toward pilot deployments with design partners. This is the stage where architecture decisions shape everything that follows.

The Team

Deepgrids was founded by a team that combines technical depth in AI and systems architecture with direct operational experience in enterprise deal execution.

Members on our team have:

• Built and shipped multi-agent AI systems in production.
• Led strategic pricing at Broadridge Financial Solutions, closing multi-million dollar enterprise deals.
• Published research in machine learning for complex relational problems.
• Designed enterprise-grade product interfaces that integrate AI capabilities with user experience.

Our advisory board includes:

• Former COO of Google Cloud and SVP of Business Operations at Palo Alto Networks.
• Former CPO of Medallia who launched four generative AI products in 2024.
• Former CMO of The Hershey Company, Capital One, and TD Ameritrade.
• Former Director of Global Business Practices at Google Cloud.

Core Principles

1. Conviction: Build from first principles.We’re not copying existing playbooks. The coordination problem requires infrastructure that doesn’t exist yet – temporal knowledge graphs, multi-agent orchestration, learned organizational memory. We pursue technically ambitious solutions because the problem demands them.
2. Ownership: Earn autonomy through results. Every team member operates with founding-level responsibility. You own your decisions, your architecture, your outcomes. We extend trust by default and expand scope as you demonstrate reliability.
3. Clarity: Make the complex navigable. Enterprise operations are messy. Our job is to create order without imposing rigidity. The systems we build should surface what matters and make the right action obvious.
4. Craft: Ship production-grade work. We’re building for enterprises that need reliability, not demos that impress in controlled environments. Every system should work correctly under real conditions with real data.

Your Role

As a Founding Engineer at Deepgrids, you’ll help build the technical foundation for coordination infrastructure that doesn’t exist yet. You will be collaborating directly with our CTO, Eshan, who oversees both technical architecture and product vision, as well as Joseph, our head of Frontend Engineering. There is no hierarchy to navigate, only experience and conviction determine how decisions get made. You’ll have real ownership over architecture choices, significant input on product direction, and a voice in hiring the engineers who come after you. This is founding-team membership, not a senior IC role with equity attached. Your judgment will shape the company.

What You’ll Build

• Temporal Knowledge Graphs: Model deals, stakeholders, dependencies, and approvals; tracking not just current state but how things evolved and what forces act on them.
• Multi-Agent Orchestration: Design specialized AI agents that handle coordination tasks within bounded contexts (surfacing blockers, drafting communications, assembling approval packages, detecting anomalies).
• Integration Layer: Connect to CRM, email, calendars, contract systems, and communication tools via MCP (Model Context Protocol) and standard APIs while maintaining data consistency.
• Rules Engine: Transform organizational policies into executable logic so the system reasons about approvals, dependencies, and escalations.
• Production AI Systems: Build reliable infrastructure around LLMs that can fail in unpredictable ways, including agent architectures, retrieval patterns, and evaluation frameworks.

Responsibilities

• High Ownership: Design and implement systems end-to-end independently; define requirements and write clean, maintainable code.
• Architecture Leadership: Make foundational technical decisions that will scale; evaluate tradeoffs with long-term implications.
• Customer Orientation: Engage with design partners to understand how enterprise deals actually move; translate operational reality into technical requirements.
• Production Mindset: Build systems that work reliably under real conditions; obsess over edge cases and failure modes.
• Team Building: Help evaluate and hire the engineers who join after you; shape engineering culture from the ground up.

Qualifications

1. Strong engineering and problem-solving ability with production enterprise/B2B software experience.
2. Depth in graph databases, knowledge graphs, or systems where modeling relationships and reasoning over connected data is central.
3. Experience building reliable systems around LLMs, including agent architectures, retrieval patterns, and evaluation frameworks.
4. Comfortable with early-stage ambiguity; you thrive when requirements evolve and ownership is high.
5. Proficiency in Python (essential), TypeScript/JavaScript (valuable).
6. Tech stack familiarity: AWS, Aurora, DynamoDB, Snowflake, S3, Flask; experience with queuing/streaming systems (SQS, Kafka, Spark) is a plus. Alternatively, Palantir Foundry + AIP.

Compensation

• Total Compensation: $150,000 to $200,000 (cash + equity).
• Benefits: Remote work.