Agentic Coder Tradeify

Skills / Requirements

• AI Fluency
• AWS
• BullMQ
• CI/CD
• Claude Code
• Docker
• FastAPI
• GitHub Actions
• Google Vertex AI
• LangChain
• LangGraph
• Next.js
• OpenAI
• PostgreSQL
• Python
• React
• Redis
• SQL
• Tailwind
• TypeScript
• Vibe Coding

Why Apply

This role is perfect for someone who leverages AI tools daily, with a focus on building multi-step AI agents and RAG pipelines. You'll use technologies like LangGraph and Anthropic APIs to create complex workflows.

What You'll Be Doing

You'll design and deploy agentic systems that directly impact users, focusing on AI-driven workflows and internal tools. Your work will involve integrating AI models with product features and optimizing trading processes.

Pay and Career Growth

Tradeify offers a high-ownership environment where your work directly impacts the product and users. You'll work on meaningful systems from day one, with a clear path to influence architecture and product decisions.

Benefits and Perks

• AI priority
• Fast feedback loop
• High ownership
• Interesting domain
• Small team

Is This Role Right for You?

Original Job Description

About Tradeify
Tradeify is a next-generation proprietary trading firm that funds futures traders — giving skilled traders access to real capital without the red tape. We offer evaluation-based and instant funding paths, letting traders choose the route that fits their style and get to profitable trading faster.
 
We’re building the infrastructure, tooling, and intelligence layer that sits behind that experience: real-time dashboards, automated journaling, risk management systems, and AI-powered workflows that help traders grow their accounts and our team operate at scale. We move fast, think in systems, and care deeply about the traders who trust us with their careers.
 

About the Role
We’re not looking for someone who “has experience with AI.” We’re looking for someone who builds with it every day — an engineer whose default instinct is to reach for an LLM, an agent framework, or a durable workflow instead of writing another for-loop.
 
This is a high-ownership, high-output role. You’ll design and ship agentic systems that touch real users and real money. You’ll work alongside a product team that moves fast and expects the same. If your idea of a good week is shipping an internal tool on Monday, wiring up a RAG pipeline on Wednesday, and deploying a Discord bot by Friday — read on.
 

What You’ll Build

Multi-step AI agents that handle complex, real-world workflows end to end

RAG pipelines that actually perform — not just LangChain defaults

Durable background workflows for processing, enrichment, and orchestration

Internal dashboards, admin tools, and integration surfaces (Slack, Discord, Intercom)

Eval harnesses to measure and improve model performance over time

The glue layer between LLMs, APIs, databases, and product features
 
What We’re Looking For
Languages & Foundations

Python 3.12 as your primary language — you live in the AI/ML ecosystem; FastAPI for AI/agent service APIs

TypeScript (strict) in a monorepo on Bun + Turborepo — Next.js (App Router), React, Tailwind, shadcn/ui for UI; Hono + tRPC for the API layer; Better Auth for authentication

Comfortable with SQL and Drizzle ORM with PostgreSQL — comfortable querying and working with a relational data model
LLM & Agent Tooling

Hands-on with Anthropic, OpenAI, and Google Vertex AI (Gemini) APIs — function/tool calling, structured outputs, prompt caching; multi-provider failover via OpenRouter and Cloudflare AI Gateway

Production experience with an agent framework: LangGraph for agent/AI services — not just a weekend project

Familiar with Model Context Protocol (MCP) — building and consuming MCP clients/servers to extend agent capabilities

You know the boring-but-critical stuff: streaming, retries, token cost management, rate limiting
RAG & Retrieval

Experience with vector DBs: pgvector (preferred), Pinecone, Weaviate, or Qdrant

Intentional about embedding models and chunking strategy — you’ve reasoned about trade-offs, not just accepted defaults

Implemented hybrid search (BM25 + vector) when precision matters
Orchestration & Workflows

Code-first workflow experience: BullMQ + Redis for queues, scheduled jobs, and durable background orchestration

Aware of low-code tools: n8n, Zapier, Make — can use them when appropriate

Background jobs, queues, and scheduled tasks are second nature
Evals & Observability

Active user of at least one eval/observability platform: Langfuse (self-hosted) for tracing and evals — our primary observability platform; familiarity with LangSmith, Braintrust, or Helicone is a plus

You’ve actually run an eval set — you have opinions on what makes a good one
AI-Native Dev Workflow

Claude Code is your daily driver — plus comfort operating within a homegrown agentic-dev layer (hooks, skills, subagents)

You ship internal tools in days, not sprints

You have a “vibe coding” instinct — but you don’t let it erode eng discipline
Infrastructure

Comfortable deploying on AWS (EC2, S3, SES, ECR, Parameter Store) in us-east-2; Docker / Docker Compose for dev and prod; Caddy for TLS and reverse proxy; GitHub Actions + OIDC for CI/CD

Docker / Docker Compose, env management, and secrets handling (AWS Parameter Store) are table stakes

Some Biome, Vitest, and Playwright familiarity is a plus for linting, unit testing, and end-to-end testing
Product Glue

Can spin up Next.js (App Router) / React dashboards and admin interfaces when needed

Familiar with Discord.js, Slack API, and Intercom API; comfortable with Asana, Fellow, and Google Workspace (Drive/Calendar/Gmail) integrations

Understands product instrumentation with Mixpanel or GA4

Bonus Points

You’ve built LLM-powered side projects that real people actually use

You understand trading or trading platforms — this accelerates your empathy with our users enormously

You have genuine opinions on model selection (Claude vs. GPT vs. open-weight) — you don’t treat them as interchangeable black boxes
 
What You Won’t Find Here

Bureaucracy slowing down good ideas

Sprints that stretch a one-day task into two weeks

A team that’s “exploring AI” — we’re building with it

Success in This Role Looks Like

30 days: You’ve shipped at least one agentic workflow or internal tool to production. You understand the codebase, the data model, and where the biggest leverage points are.
 

60 days: You own a meaningful system — a RAG pipeline, a durable workflow, a Discord or Intercom integration — and it’s running reliably with observability in place. You’ve run your first eval set on a prompt-sensitive workflow.
 

90 days: You’re proactively identifying new places where AI can reduce manual work or improve trader experience. Your code is in production and measurably working. The team is shipping faster because of the systems you’ve built.
 

Long-term: You’re the person we call when a new LLM capability drops and we need to figure out what it means for our stack. You’ve built things traders and the internal team actually rely on daily.

 
Why Join Tradeify

You’ll work on a real, fast-moving product. We’re not a research team or an internal tools shop. Our platform serves thousands of traders. The things you build get used immediately and the feedback loop is short.
 

AI is a first-class priority, not an afterthought. We’re investing heavily in agentic workflows, intelligent tooling, and AI-powered trader support. You’ll have room to do genuinely interesting work, not just prompt-wrap CRUD apps.
 

Small team, high ownership. You won’t be one of twenty engineers on a feature squad. You’ll have direct influence on architecture and product decisions from day one.
 

The domain is genuinely interesting. Futures trading, risk management, payout systems, trader performance analytics — there’s no shortage of complex, high-stakes problems worth solving well.
 

We use the tools we ask you to know. Claude Code, LangGraph, Langfuse — these aren’t on the JD to sound current. They’re in our stack.