Senior Software Engineer, Frontend

Ruxlo; New Jersey; On-site; USD 140,000 - 190,000; Full time

Job summary

Ruxlo is redefining home records with a map-first SaaS frontend. We are seeking a Senior Frontend Engineer who can own the client layer across Flutter/Dart mobile apps and Next.js/React web app, balancing performance, accessibility, and developer productivity.

You will shape the design system, rendering strategy, and AI-assisted features, shipping across iOS, Android, and web, with a focus on real-world performance on mid-range devices and flaky networks.

Qualifications

• 5+ years building and operating production frontends, with genuine shipping experience on both mobile and web.

Responsibilities

• Own the client layer across Flutter/Dart apps and Next.js/React web app; define architecture, state, navigation, and design language.
• ],
• CoT_job_summary_short
• job_summary_short
• CoT_job_summary_short
• job_summary_short
• CoT_job_summary_short
• job_summary_short

Skills

Multiplatform frontend

Flutter/Dart

Next.js/React

TypeScript

Cross-platform judgement

Frontend performance

Design systems

WCAG accessibility

REST/GraphQL

CI/CD

Automated testing

Frontend shipping experience

Tools

Flutter/Dart (production)

Next.js/React

TypeScript

REST/GraphQL

CI/CD tooling

Job description

LinkedIn is your professional network. Facebook and Instagram are your social networks.

Ruxlo is your Home's Network.

At the center of Ruxlo is a 150 million property profiles. Most of what happens to a house is forgotten, and what survives is scattered across a county filing, a shoebox of receipts, and the memory of whoever owned the place three families ago. We're replacing that with one durable record attached to the parcel itself. Work is recorded by the contractor who did it and confirmed by the owner who paid for it. When the house sells, the record stays, think CARFAX for homes.

Around the property are your neighbors who you can connect with, see their Property Profiles and the contractors they’ve used. Further out is your town, where you choose notifications such as farmers markets, recycling or bulk waste pickup.

We're early-stage, backed by an experienced SaaS founder — a unique opportunity to help define a category at the intersection of AI, data, and the largest asset class in the country.

About the Role

Everything a user knows about Ruxlo, they learn through a screen we built. The map, the property profile, the search box, the confirmation flow, the credit meter — that's the product, as far as anyone outside the company is concerned. You'll own that layer.

This is a multi-platform role, and that is the whole point. Our mobile apps are Flutter/Dart on iOS and Android; our web app is Next.js/React. We're not looking for someone deep on one who's willing to learn the other — we want an engineer who has genuinely shipped and operated both native-mobile and modern web frontends, and who has the judgment to know what should be shared across them (design language, data contracts, product logic) and what costs more to share than to simply build twice.

You're building at parcel scale, on a map. 150M+ properties, a map-first interface, AI-assisted search that streams its answers, and a freemium meter running underneath. The hard problems here are rendering performance, state, and the honest handling of slow and non-deterministic responses — not CRUD screens.

And SEO is a product requirement, not an afterthought. A profile page for every property in America only compounds if those pages rank — in search engines and increasingly in AI answer engines. Web rendering strategy, structured data, and Core Web Vitals are part of your mandate, not someone else's.

This is a senior IC role building on real foundations, not from zero. There's a monorepo, a web app, and mobile apps already in production. But the component architecture, the shared design system, the rendering and performance bars, and the release process are still yours to set — and the product's appetite is growing faster than any of them. The standards you set early become how Ruxlo does frontend as it scales.

You're hands-on and pragmatic. You'd rather ship a fast, accessible screen than write a framework proposal about one. You care about what the user actually feels — time to first pixel, scroll jank on a three-year-old Android, what happens when the network drops mid-flow — and you use AI-assisted tooling so your time goes to interaction design and performance rather than boilerplate.

What You'll Do

• Own the client layer across platforms. Set the component architecture, state model, navigation, and shared design language across the Flutter/Dart apps and the Next.js/React web app — one product, three surfaces, and a frontend strategy other engineers build on.
• Ship the map. The map is the primary interface, not a widget on a page. Own tile and marker rendering, clustering, viewport-driven queries, and the interaction performance that makes 150M+ parcels feel instant.
• Build for search and AI answer engines. Own web rendering strategy — server rendering, incremental static regeneration, structured data, sitemaps — and the Core Web Vitals that decide whether our property pages rank or disappear.
• Make AI features feel good. Streaming responses, honest loading and uncertainty states, optimistic updates, and a credit meter and paywall the user understands. Non-deterministic backends demand interfaces designed for them.
• Own the design system. Partner with Design to turn Figma into tokens and reusable components that hold up across web and mobile, so the product stays coherent as surfaces multiply.
• Own the release trains. App Store and Play review, code signing, staged rollouts, feature flags, forced-upgrade paths, and web continuous delivery — plus the crash and regression response when something slips through.
• Hold the bar on real devices. Performance and accessibility measured on mid-range Android and flaky networks, not on your laptop. You use production signals to catch regressions early.
• Set the standard. Make the build-vs-buy and cross-platform sharing calls, and let the patterns you establish become the team's default.

Ownership & AI-native

• Able to own an area end to end with limited guidance and establish patterns from scratch on real foundations.
• AI-native by default: you use AI tools to multiply your output — and verify what they produce.

What You Bring

Required

Multi-Platform Frontend (the core of this role)

• Flutter/Dart in production on both iOS and Android — real apps shipped through the App Store and Google Play and operated after launch, not prototypes or a side project.
• Strong Next.js/React with TypeScript, including rendering strategy — server-side rendering, static and incremental static regeneration, client hydration — and the judgment to pick the right one per route.
• Cross-platform judgment. You can reason about what should be shared across web and mobile and what shouldn't, and you've been burned enough by premature abstraction to know the difference.
• State, data, and the network. State management, data fetching, caching, offline and flaky-network handling, optimistic updates, and conflict resolution — because mobile users aren't always on WiFi.
• Frontend performance. Render and rebuild profiling, list and map virtualization, bundle size, image strategy, and Core Web Vitals.
• Design systems and accessibility. Building reusable component libraries from design tokens, and meeting WCAG-level expectations as a default rather than a retrofit.
• Disciplined API consumption. REST and/or GraphQL with real awareness of contracts, versioning, pagination, and error semantics — and the willingness to push back on a backend contract that won't serve the client well.
• 5+ years building and operating production frontends, with genuine shipping experience on both mobile and web.
• Continuous integration and delivery for web and mobile: automated builds, code signing, store submission, staged rollout, and feature flags you trust.
• Automated testing as a habit — unit, widget/component, and end-to-end — built in partnership with QA rather than left to them.
• Client-side observability: crash reporting, real-user monitoring, and performance budgets you actually enforce.

Preferred

• Founding-team or early-stage experience owning frontend on a lean team.
• Map and geospatial rendering — Mapbox, MapLibre, or Google Maps, vector tiles, clustering, and marker performance at parcel scale.
• Programmatic SEO at scale — sitemaps, structured data (schema.org), and answer-engine optimization for AI search.
• Streaming and agentic AI interfaces — token streaming, tool‑call and human-in‑the‑loop states, and designing for non-deterministic responses.
• Freemium, paywall, subscription, and in-app purchase flows (StoreKit, Google Play Billing, RevenueCat, or similar).
• Offline-first architecture, local persistence, and sync conflict handling.
• Design-system ownership and close partnership with a product designer in Figma.
• Native platform work in Swift or Kotlin for platform channels and plugins.
• Analytics, funnel instrumentation, and A/B experimentation.
• Accessibility to WCAG standards.
• Proptech, real estate, fintech, or geospatial experience.

Ruxlo LLC is an Equal Opportunity Employer.

AI disclosure: As part of our recruiting process, Ruxlo may use AI-assisted tools to help screen, review, and organize applications, as well as to support scheduling and communication. These tools assist our team and all final hiring decisions are made by humans. We work to ensure these tools are used fairly and without unlawful bias. If you have questions about how AI is used in your application, would like to request a reasonable accommodation or an alternative review process, please contact us at [phone].