Full-Stack Software Engineer

Aperium is building an agent-enabled software platform for working across the systems an organization already uses. Our first product is an agentic ERP workspace, but the underlying libraries, integration runtime, and user-interface foundations are also being used in products for software delivery and situational awareness.

We are not trying to predict every future use case or build a universal framework in advance. We are building well-defined, reusable capabilities that solve real product needs today and can be composed into different applications without copying the core or forcing every product into the same shape.

You will bring full-stack product and platform engineering depth to a team with strong machine-learning expertise. You will help turn agent and ML capabilities into dependable software: services and data models, APIs and contracts, user interfaces, reusable libraries, operational tooling, and the engineering practices that connect them.

This is a hands-on role with meaningful influence over the architecture. The current system contains strong opinions, but those decisions are not beyond review. We expect you to understand why a design exists, test it against current and emerging product needs, and improve or replace it when the evidence supports doing so.

• Deliver product capabilities end to end, from domain and data modeling through backend implementation, API design, frontend behavior, and production operation.
• Design clear interfaces between reusable platform code and product-specific applications so that shared capabilities can evolve without creating unnecessary coupling.
• Build accessible, responsive, and maintainable user experiences for complex workflows and data, including asynchronous operations, large collections, visualizations, and product-specific extensions.
• Develop reliable backend services for stateful workflows, external-system integrations, authorization, data access, background processing, and failure recovery.
• Define and evolve contracts across service, library, integration, and frontend boundaries, including compatibility and migration strategies for existing consumers.
• Work closely with ML engineers to integrate model behavior into understandable product experiences, with appropriate evaluation, feedback, error handling, and human control.
• Improve performance, security, observability, and operational reliability based on production risks and measured behavior.
• Strengthen developer experience and software quality with proportionate testing, automation, static analysis, documentation, and delivery safeguards.
• Contribute through design discussions, code review, pairing, and mentoring. Help the team make sound engineering decisions without turning every decision into process.

• A track record of building and operating production web applications or platforms across meaningful parts of both the frontend and backend.
• Deep expertise on at least one side of the stack and the ability to work effectively across the other. We value end-to-end ownership more than an artificially even skill profile.
• Proficiency with a typed programming language and a modern component-based frontend framework. You should be able to become productive in typed Python and React with TypeScript, but prior use of every library in our stack is not required.
• Strong fundamentals in API design, data modeling, relational databases, distributed or asynchronous systems, and browser application architecture.
• Experience designing interfaces, libraries, components, or services that other engineers depend on, and managing their evolution as requirements change.
• Practical judgment about abstraction: able to separate durable patterns from product-specific behavior without designing for hypothetical consumers.
• A disciplined approach to testing, security, failure handling, compatibility, and production diagnostics.
• The ability to work through ambiguity, explain tradeoffs clearly, and turn decisions into code and documentation that others can maintain.
• A collaborative approach to technical leadership, especially when working with engineers whose primary expertise is outside traditional application development.

If your experience is stronger in some of these areas than others, we still encourage you to apply. We are hiring a team, not looking for several copies of the same engineer.

Engineers will independently lead substantial features or subsystems, make sound local architecture decisions, operate what they build, and improve the effectiveness of the engineers around them as well as shape technical direction across products and repositories, clarify ownership and platform boundaries, lead difficult migrations or cross-cutting initiatives, and help the organization make coherent decisions as the product portfolio grows. This remains a hands-on engineering role.

• Building platforms, SDKs, plugin systems, design systems, or other extensible software used by multiple teams or products.
• Developing AI-assisted products, agent workflows, model/tool integrations, evaluation systems, or human-in-the-loop controls.
• Designing secure multi-tenant applications, policy or authorization systems, or software for regulated and high-assurance environments.
• Working with durable workflows, event-driven systems, external integrations, or long-running background processes.
• Building data-intensive interfaces such as analytical applications, virtualized tables, timelines, maps, or other interactive visualizations.
• Operating distributed systems with structured logging, metrics, tracing, profiling, and incident-driven reliability improvements.
• Working in a monorepo or maintaining shared libraries with multiple independent consumers.
• Contributing to developer tooling, open-source projects, or engineering standards across a team.

Our exact tools will change as the products and team mature. The important expectation is that you can reason about the underlying engineering problems and help us choose appropriate solutions.

Today, our backend is primarily typed Python, with asynchronous HTTP services, schema-validated contracts, PostgreSQL-backed persistence, analytical data processing, and durable background workflows. Our web applications are built with React and TypeScript from shared UI foundations that downstream products can extend. The platform integrates with external systems and model providers through typed, composable interfaces. We use automated testing, static analysis, continuous integration, structured logging, distributed tracing, and behavioral evaluation to support safe delivery.

Experience with technologies such as FastAPI, Pydantic, React, TypeScript, PostgreSQL, workflow engines, geospatial systems, or LLM tooling may help you ramp up, but we do not treat exact tool matching as evidence of engineering ability.

• We ship complete, usable increments and keep shared code connected to concrete product needs.
• We favor clear ownership, explicit contracts, and simple implementations over speculative abstraction.
• We treat architecture as a set of tradeoffs to revisit as evidence and product requirements change.
• We expect engineers to own quality and operability as part of implementation, not as a separate handoff.
• We document durable decisions near the code and automate important constraints where doing so reduces real risk.
• We use AI-assisted development extensively, with human review and engineering controls appropriate to the impact of the change.