The Role

You'll build the applications that make autonomous building systems legible to humans.

PassiveLogic's platform enables buildings to reason about their own operation using physics-based digital twins. The software you build is how users construct those twins, simulate building behavior, and interact with deployed autonomous systems. This isn't dashboard work—it's spatial, interactive, and often real-time. You'll render building models, visualize system behavior, and design interfaces that make complexity navigable rather than hidden.

Our architectural philosophy rejects black-box AI. Users should understand what the system is doing and why. That constraint shapes everything about how we build interfaces—it demands clarity, not just functionality.

What You'll Build

Applications for constructing physics-based models. Users describe buildings and their mechanical systems through our tools. You'll build interfaces for creating, editing, and validating these models—work that combines structured data editing, spatial visualization, and domain-specific interaction patterns.

Simulation and visualization tools. Before deploying autonomous control, users simulate building behavior. You'll build the interfaces that display simulation results, highlight anomalies, and help users develop intuition about how their buildings will perform.

Operational interfaces for deployed systems. Once buildings are running autonomously, operators need to monitor, understand, and occasionally override system behavior. You'll build interfaces that surface the right information at the right moment without overwhelming users with data they don't need.

Real-time collaborative features. Our applications are local-first—designed to work offline and synchronize when connected. You'll work with distributed data patterns (conflict resolution, optimistic updates) that most front-end roles never encounter.

The Technical Environment

Our stack is TypeScript and Angular, with significant use of reactive programming patterns. We render building models and system schematics using WebGL and SVG—if you have graphics programming experience, you'll use it; if you don't, you'll develop it.

The platform architecture is evolving toward Swift compiled to WebAssembly for core logic, with TypeScript at the application layer. You won't own that integration boundary (that's framework-level work), but you'll build on top of it and provide feedback that shapes how it develops. Understanding how to work effectively with that architecture—consuming reactive state from WASM modules, working within the patterns the framework provides—will be part of the role.

We use a graph-based data model called Quantum for describing autonomous system digital twins, synchronized via a real-time protocol called DataSync. You'll learn these systems; prior familiarity isn't expected.

What We're Looking For

Strong TypeScript and JavaScript fundamentals. You've built substantial applications in TypeScript, understand the type system deeply, and write code that other engineers can read and maintain.

Experience with modern front-end frameworks. Angular, React, Vue, Svelte—the specific framework matters less than understanding the underlying patterns: component architecture, state management, reactive dataflow, change detection. You should be able to reason about why frameworks make the tradeoffs they do.

Comfort with complexity. The applications we build aren't simple CRUD interfaces. You're energized rather than overwhelmed by domains with many interacting concepts. You can hold a mental model of a complex system and build interfaces that help users develop their own.

Visual and spatial thinking. Much of our UI is graphical—building schematics, system diagrams, data visualization. You don't need to be a designer, but you should be comfortable reasoning about spatial relationships, visual hierarchy, and interaction in two (and sometimes three) dimensions.

Attention to craft. You care about the details that separate adequate interfaces from excellent ones—animation timing, interaction feedback, edge case handling, performance under load. You notice when something feels slightly off and you fix it.

Experience level. Typically 4+ years building front-end applications, with at least some of that time on complex, data-rich interfaces. We're looking for engineers who've moved past the "making it work" phase into the "making it right" phase.

Helpful Experience (Not Required)

Graphics programming—WebGL, Three.js, D3, SVG manipulation. We do a lot of this.

Real-time data visualization or applications with live-updating state.

Local-first or offline-capable application architecture.

Domain experience in building systems, energy, IoT, or industrial software. (Helpful for intuition, but we'll teach the domain.)

Experience consuming platform APIs or working within opinionated framework architectures.

The Team

The UI team owns all user-facing applications on the PassiveLogic platform. You'll work alongside other application engineers, a Framework Architect focused on platform integration, and designers who take human-centered interface design seriously. Collaboration with the platform team (who build the Swift core) and hardware team (who build the physical controllers) is regular—the boundaries are permeable by design.

We do code review as genuine technical discussion, not rubber-stamping. We document decisions because we've learned what happens when we don't. We optimize for understanding over velocity, though we ship consistently.

The culture is technically serious without being precious. We debate architectural tradeoffs rigorously, but we also recognize when something is a matter of preference rather than correctness. If you're someone who can disagree constructively and change your mind when presented with better arguments, you'll fit.

Growth

Senior application engineers at PassiveLogic grow in multiple directions. Some develop deep expertise in specific domains—graphics, real-time systems, complex interaction design. Some move toward technical leadership, owning entire application surfaces and coordinating across teams. Some develop interest in the framework layer and shift toward platform work.

We're a 150-person company with substantial technical ambition. There's room to shape your trajectory based on what you're good at and what you find interesting.

Who This Role Is Not For

Engineers looking for simple, well-specified feature work. The problem space is genuinely complex, and you'll spend significant time understanding before building.

Engineers who view front-end development as less serious than "real" engineering. The interfaces we build are where humans meet autonomous systems. Getting them right has consequences.

Engineers who need constant direction. You'll have support and collaboration, but you'll also be expected to take ownership—identifying problems, proposing solutions, and driving them to completion.

Location

Most of the UI team is in Salt Lake City. We prefer local candidates or those open to relocation, but we'll consider strong remote candidates who communicate well asynchronously and can overlap with Mountain Time for collaboration.

Compensation

Competitive salary plus equity. The specific range depends on experience; we're committed to paying fairly for the level of work we're asking for.

To Apply

If building interfaces for novel, complex systems sounds like work you want to do, reach out. Show us what you've built—a portfolio, side projects, or open source contributions tell us more than credentials alone.