Founding Software Engineer — Platform & Backend

Earthinia

Earthinia is building an enterprise AI workforce platform that enables businesses to create AI-powered operational teams composed of specialized roles, tools, knowledge, permissions, integrations, and communication channels.

We are looking for a Founding Software Engineer — Platform & Backend to join Earthinia at an early stage and take significant ownership of the software platform that powers our AI workforce infrastructure.

You will work directly with the founder and our Agentic AI engineering function to build the APIs, services, data systems, security controls, integrations, billing infrastructure, and distributed systems required to operate Earthinia reliably at production scale.

This role is focused primarily on software and platform engineering, rather than AI model research.

What You Will Own

• Design, build, and maintain Earthinia's backend platform.
• Develop production-grade APIs using Python and FastAPI.
• Design reusable and maintainable service, repository, domain, and API layers.
• Build and maintain Earthinia's account, cluster, instance, tool, knowledge, execution, channel, and integration services.
• Design secure authentication and authorization systems.
• Implement account and resource-level permissions.
• Build cluster-scoped API key generation and management.
• Develop subscription, billing, credit, usage, and entitlement systems.
• Build usage metering and reporting infrastructure.
• Design PostgreSQL database models, migrations, indexes, and queries.
• Build Redis-backed caching, sessions, rate limiting, and execution-state systems.
• Develop WebSocket and real-time communication infrastructure.
• Build event-driven and asynchronous processing systems.
• Develop external service and business-system integrations.
• Support Earthinia's Python and TypeScript SDK infrastructure.
• Build APIs that allow customers to integrate Earthinia into their own products.
• Implement secure communication between platform services and the AI execution runtime.
• Develop audit logging and execution-history infrastructure.
• Implement reliable background jobs and workflow processing.
• Design retry, idempotency, error-handling, and failure-recovery mechanisms.
• Improve system performance, scalability, and reliability.
• Implement automated testing and quality assurance.
• Help maintain CI/CD and production deployment workflows.
• Work with AWS infrastructure including EKS, RDS, Redis, networking, secrets, storage, and related services.
• Help define engineering standards for code quality, architecture, documentation, security, and maintainability.

How This Role Works With the Agentic AI Engineer

The responsibilities are intentionally separated.

The Agentic AI Engineer owns areas such as:

• Agent reasoning
• Planning
• Multi-agent orchestration
• Tool selection
• Model routing
• Agent memory
• RAG
• MCP
• AI evaluations
• Agent execution intelligence

The Software Engineer owns the production platform surrounding those capabilities.

For example:

If the Agentic AI Engineer builds logic that allows a Sales Instance to select and execute a CRM tool, you may build the systems that:

• Authenticate the customer
• Determine which account owns the cluster
• Verify permissions
• Retrieve integration credentials securely
• Manage the API request
• Store execution state
• Enforce subscription limits
• Meter usage
• Record audit events
• Handle failures and retries
• Return the execution result through the API

Together, these systems make Earthinia usable as a secure production platform.

Example Platform Workflow

A customer could send a request through Earthinia's API:

"Analyze our new leads, identify the highest-priority opportunities, prepare outreach, and update our CRM."

The AI runtime determines how the work should be performed.

Your platform infrastructure ensures:

• The request is authenticated.
• The correct account and cluster are identified.
• Subscription and usage limits are validated.
• The requested instances have the necessary permissions.
• Integration credentials are retrieved securely.
• Execution state is created and persisted.
• Events can be delivered between system components.
• Usage is recorded.
• Results are securely returned to the customer.
• Execution history is available for auditing and debugging.

Current Technology Environment

Earthinia's engineering environment includes technologies such as:

• Python
• Python 3.12
• FastAPI
• Pydantic
• SQLAlchemy
• PostgreSQL
• Amazon Aurora PostgreSQL
• Redis / Valkey
• REST APIs
• WebSockets
• Docker
• Kubernetes
• Amazon EKS
• AWS
• Terraform
• GitHub Actions
• OpenAPI
• TypeScript
• React
• Event-driven systems

You do not need to know every technology before joining, but you should have strong backend engineering fundamentals and be capable of learning unfamiliar systems quickly.

What We're Looking For

Strong experience in several of the following areas is preferred:

• Python
• FastAPI or similar backend frameworks
• PostgreSQL
• SQLAlchemy or other ORMs
• Redis
• REST API design
• Distributed systems
• Authentication and authorization
• OAuth/JWT
• API security
• WebSockets
• Event-driven systems
• Background job processing
• Cloud infrastructure
• AWS
• Docker
• Kubernetes
• Terraform
• CI/CD
• SaaS billing systems
• API integrations
• Software architecture
• Automated testing
• Observability
• Performance optimization

You May Be a Strong Fit If You

• Have built and shipped production backend systems.
• Can design APIs rather than simply implement predefined endpoints.
• Understand database design and data integrity.
• Understand authentication, authorization, and multi-tenant SaaS security.
• Think carefully about failure modes and reliability.
• Write clean, modular, reusable, and maintainable code.
• Understand the importance of testing.
• Can reason about distributed systems.
• Are comfortable working with cloud infrastructure.
• Can independently investigate and solve difficult engineering problems.
• Can make architectural decisions and explain their tradeoffs.
• Are comfortable working directly with a founder.
• Can operate effectively in an early-stage startup with evolving requirements.
• Care about building systems correctly rather than simply making them work once.
• Want substantial ownership over the product you are building.

Nice to Have

Experience with any of the following would be valuable:

• AI or LLM-powered applications
• Agentic AI platforms
• OpenAI or Anthropic APIs
• MCP
• RAG systems
• SaaS billing
• Stripe or PayPal integrations
• AWS EKS
• Aurora PostgreSQL
• Redis / ElastiCache
• Infrastructure as Code
• SDK development
• Developer platforms
• Multi-tenant enterprise SaaS
• Security or compliance systems
• High-availability systems

Engineering Philosophy

We want Earthinia's engineering organization to prioritize:

• Readability
• Reusability
• Maintainability
• Security
• Testing
• Observability
• Clear architecture
• Documentation
• Automation
• Reliability

We do not want unnecessary complexity simply because a technology is popular.

Engineers should understand the problem being solved, choose appropriate abstractions, document important architectural decisions, and build systems that future engineers can understand and extend.

Early-Stage Environment

Earthinia is an early-stage company.

This means you will have significantly more ownership than you would typically receive inside a large engineering organization.

You may help define architecture, engineering practices, APIs, data models, produc