Backend Engineer

Founding Role at Maestrotech Inc

Maestrotech Inc is building an agentic OS for mortgage origination, transforming how loans are structured, priced, submitted, and cleared across TPO portals with AI native agents and workflows. We are hiring a founding Backend Engineer to own the orchestration layer that glues agents to real-time frontend state, builds domain specific MCP servers, hosts small model inference endpoints, and implements the business logic that powers mortgage origination at scale.

You are not building traditional REST APIs or microservices. Instead, you are building the orchestration and systems integration layer that enables real-time bidirectional state sync between the agentic runtime and the user-facing application, manages durable mortgage workflows, and provides agents with composable, reliable MCP servers that encapsulate domain logic.

You will design and implement domain-specific MCP servers that agents consume as tools, build FastAPI internal services for orchestration and small model inference, manage multi tenant loan state machines, and work hand-in-hand with the AI Agent Engineer, Frontend Engineer, and Ops team to ship a cohesive agentic origination platform.

Why Join Maestrotech

• Join an ambitious founding team building the operating system for mortgage origination using truly AI native agents and workflows
• Own the orchestration and integration layer that connects agents to real-time user interactions, without the complexity of traditional API-first architecture
• Design and build domain-specific MCP servers that become canonical tools for pricing, structuring, submission, and conditions management—reusable across agents and workflows
• Host and optimize small model inference endpoints (Embedding Gemma, lightweight classifiers, scoring models) with AWS Bedrock and custom FastAPI services for ultra low latency
• Work at the intersection of agent runtime, product workflows, and user experience— translating complex mortgage origination logic into reliable, observable systems Shape how AI agents interact with durable workflows, state machines, and multi tenant data isolation at massive scale in financial services

What You Will Do

• Design and implement domain-specific MCP servers for mortgage origination: loan product lookup, pricing engine, TPO portal submission, conditions tracking, document retrieval, and underwriting rule application—each encapsulating business logic that agents call via code execution
• Build FastAPI internal services for orchestration, state management, and small model inference: no REST APIs exposed externally, but fast, type-safe internal APIs that coordinate agent execution, frontend state updates, and workflow transitions
• Architect durable mortgage workflows using state machines: track loans through application, processing, underwriting, approval, and funding states with clear transitions, rollback paths, and error recovery—ensuring workflows survive failures and maintain correctness
• Implement real-time bidirectional state synchronization between agent runtime and frontend application: manage loan state, agent progress, user interventions, and UI updates without polling or traditional request/response cycles
• Host and optimize small model inference endpoints: fine-tuned Embedding Gemma for retrieval, lightweight classification or scoring models, and decision models using AWS Bedrock and custom FastAPI services, with attention to latency, throughput, and cost
• Design and enforce multi-tenant data isolation at the application layer: ensure all MCP servers, workflows, and state management operate within tenant-specific boundaries using indexed metadata, schema-based isolation, and explicit tenant validation
• Build loan state models and business logic in Python: pricing rules, structuring logic, submission formats for TPO portals, conditions workflows, and underwriting rule engines—translating domain complexity into clear, testable code
• Implement observability and instrumentation: structured logging, distributed tracing across MCP servers and agent calls, metrics for state transitions and workflow performance, and dashboards for understanding system behavior in production
• Collaborate tightly with AI Agent Engineer to refine MCP server contracts, ensure agents can call MCP servers efficiently via code execution, and iterate on tool design based on agent usage patterns
• Collaborate with Frontend Engineer to define state shapes, real-time update patterns, and intervention points where users can review, approve, or redirect agent actions in mortgage workflows
• Collaborate with Ops team on deployment of small model endpoints, cost optimization for inference, and monitoring of workflow health and performance

How We Build Backend at Maestrotech

MCP servers are the primary abstraction for domain logic: rather than ad hoc agent SDK integrations or direct database access, agents interact with mortgage origination capabilities via well-defined MCP servers that can be tested, versioned, and evolved independently

FastAPI internal services handle orchestration and state management without exposing REST APIs: tight integration with agent runtime, real-time state updates to frontend, small model inference, and business logic orchestration all happen via internal FastAPI routes and WebSocket connections

State machines and durable workflows are explicit and testable: loans flow through named states with clear transitions, each transition validated and logged, with clear error paths and human intervention points—not implicit workflows buried in agent prompts

Small model inference is hosted and optimized: fine-tuned Embedding Gemma endpoints for retrieval (via AWS Bedrock or custom FastAPI), lightweight classifiers and scoring models for loan decisions, all with latency budgets and cost awareness

Multi-tenant correctness is non-negotiable: every MCP server, workflow transition, and state update includes explicit tenant validation using indexed metadata and schema-based isolation, ensuring no data ever crosses tenant boundaries Observability is built in from day one: structured logging captures MCP server calls, workflow transitions, state changes, and errors; distributed tracing connects agent execution to backend operations; metrics track performance and anomalies Code execution with MCP is the agent interface: agents write and run Python code that calls MCP servers, filters and transforms results, and persist state—backend provides fast, reliable MCP implementations that make this pattern work at scale

What You Will Do (Detailed)

MCP Server Development

• Design MCP server contracts for mortgage domain: define clear inputs, outputs, and error handling for pricing, structuring, submission, conditions, and underwriting services
• Implement loan product lookup MCP server: query available products, rates, terms, investor guidelines, and origination rules based on borrower profile and loan characteristics
• Implement pricing engine MCP server: calculate rates, fees, and total loan costs based on borrower profile, loan amount, term, credit score, LTV, and current market data
• Implement TPO portal submission MCP server: format loans according to TPO specifications, validate submission readiness, submit to portals, and track submission status
• Implement conditions and underwriting MCP server: track underwriting conditions, query investor guidelines, apply underwriting rules, and manage condition approval workflows
• Implement document retrieval MCP server: query mortgage documents by loan, borrower, or document type with secure multi-tenant access
• Use Claude SDK for MCP server construction, ensuring agents can discover tools and call them via code execution with low latency and clear error messages

Orchestration and State Management

• Design loan state machines: application, processing, underwriting, approval, funding, and closing states with clear transitions, validation rules, and rollback logic
• Implement durable workflow orchestration: track loans through states, persist state changes, handle retries and failures, and maintain workflow history for audit trails
• Build real-time state sync to frontend: WebSocket or similar patterns to push loan state updates, agent progress notifications, and user intervention prompts to the UI without polling
• Manage human-in-the-loop workflows: define intervention points where users can review agent decisions, approve actions, or redirect workflows before agents proceed
• Implement distributed state management: handle concurrent requests on the same loan, optimistic updates, conflict resolution, and eventual consistency patterns where needed

Small Model Inference and Optimization

• Host fine-tuned Embedding Gemma endpoints: either via AWS Bedrock or custom FastAPI services, optimize for latency (<100ms target), and manage batch vs real-time inference trade-offs
• Implement lightweight classification or scoring models: loan decision models, fraud detection, completeness scoring, or priority routing that run fast and consume minimal resources
• Optimize inference cost: use quantization, batching, and AWS pricing models to keep small model inference cost-effective at scale
• Build inference monitoring: track latency, throughput, error rates, and model performance to catch issues before they impact loan processing Business Logic and domain Implementation
• Implement pricing rules and logic: fee structures, rate adjustments, APR calculations, and cost estimation based on loan characteristics and market conditions
• Implement loan structuring logic: determine loan terms, amortization schedules, prepayment rules, and investor alignment based on borrower profile and investor guidelines
• Implement underwriting rule engines: translate investor guidelines and regulatory requirements into executable rules that gate loan progression
• Implement TPO portal format specifications: encode submission rules, field mappings, and validation logic for different TPO partners
• Build audit trails and compliance logging: capture who did what, when, and why for regulatory and internal audit purposes

Multi-Tenant Architecture

• Design tenant isolation at the application layer: use indexed metadata, schema-based partitioning, or row-level security to ensure MCP servers and workflows operate within tenant boundaries
• Implement explicit tenant validation: every MCP server call, workflow transition, and state update includes tenant context validation to prevent cross-tenant data leaks
• Optimize multi-tenant performance: minimize per-request overhead, design indexes and queries for tenant-scoped access, and monitor query performance across tenants

Observability and Instrumentation

• Implement structured logging: log MCP server calls, workflow transitions, state changes, errors, and user actions with context and correlation IDs for debugging
• Build distributed tracing: trace agent execution through MCP server calls, backend services, and frontend updates to understand end-to-end behavior Create dashboards and alerting: monitor workflow health, state transition rates, error rates, inference latency, and other key metrics; alert on anomalies or failures
• Instrument for agent observability: provide telemetry that the AI Agent Engineer can use to understand agent behavior, debug agent issues, and refine agent designs

What We Are Looking For

• Strong backend engineering skills with proven ability to design and build systems that handle complex state, distributed workflows, and multi-tenant data isolation
• Deep Python proficiency: you write fast, maintainable, well-tested Python code and understand async/await patterns, type hints, and performance optimization
• Experience building orchestration and state management systems: you have shipped systems with state machines, durable workflows, or similar patterns, and understand error recovery and consistency challenges
• Practical experience with MCP, tool abstractions, or similar patterns where backend logic is surfaced as composable, reusable tools consumed by agents or frontends
• Familiarity with small model inference and optimization: you understand when to use small vs large models, how to optimize for latency and cost, and can work with deployment tools like AWS Bedrock or FastAPI
• Strong understanding of multi-tenant architecture: you know how to design systems that safely isolate data across tenants, prevent cross-tenant leaks, and maintain performance
• Experience building real-time or streaming systems: you understand WebSockets, event streams, or similar patterns for pushing updates to frontends without polling
• Product sense and ability to translate mortgage domain workflows into reliable backend services: you ask good questions about requirements, edge cases, and user experience, and build systems that are intuitive for both users and agents
• Comfort with AWS: you use AWS services fluently, including EC2, RDS, S3, Lambda, and Bedrock for AI model inference; you understand cost and performance trade offs

Technical Skills

• Python and FastAPI: Build fast, type-safe internal APIs with FastAPI; async/await patterns for concurrency; Pydantic for data validation and schema definition; ASGI servers and performance tuning
• MCP Servers: Claude SDK for MCP server construction; tool definition specification; parameter handling and response formatting; testing and debugging MCP servers State
• Machines and Workflows: Design and implement loan state machines; durable workflow orchestration; error recovery and retries; distributed state management and conflict resolution
• Small Model Inference: Host and optimize Embedding Gemma or similar models; AWS Bedrock integration; FastAPI inference endpoints; latency optimization and cost management
• Multi-Tenant Architecture: Indexed metadata and schema-based isolation; row level security patterns; tenant validation and authorization; performance optimization for multi-tenant queries
• Real-Time Systems: WebSocket patterns for real-time state sync; event-driven architectures; eventual consistency; handling concurrent updates and rollbacks .
• Database Design: PostgreSQL schema design for multi-tenant data; indexing strategies; query optimization; handling distributed transactions and state consistency
• Observability: Structured logging (JSON logs, correlation IDs); distributed tracing (OpenTelemetry or similar); metrics collection and dashboarding; alerting and incident response
• AWS Ecosystem: EC2, RDS, S3, Lambda, Bedrock, CloudWatch; IAM and security; cost optimization; infrastructure as code (CloudFormation or Terraform)
• Code Execution Safety: Understanding Python sandboxing, resource limits, and security considerations when agents execute code that calls MCP servers

Nice To Have

• Experience with Temporal, Cadence, or similar workflow orchestration platforms— understanding of durable execution patterns
• Familiarity with mortgage origination, underwriting rules, investor guidelines, or TPO workflows—ability to translate domain complexity into clear backend logic
• Contributions to MCP server implementations or open source agent frameworks
• Experience with embeddings and retrieval systems (vector databases, reranking, hybrid search)—understanding how to support retrieval workflows
• Previous work on financial services backends with strong compliance and audit requirements
• Experience optimizing inference costs with AWS Bedrock or similar AI services
• Knowledge of contemporary agentic patterns: agent memory, tool composition, code execution contexts, and how backends can support agent reasoning at scale

The Opportunity

You will design and build the orchestration and integration layer that transforms agentic AI from academic concepts into production mortgage origination systems. You will own MCP servers that agents and frontends depend on, manage durable workflows that move billions in loans through origination, and work at the intersection of agent reasoning, real time user interaction, and financial services correctness. You will shape how backends support agents at scale—with fast, reliable tools; observable, auditable workflows; and clear boundaries between agent, user, and system. If this resonates, we would love to talk.