Senior Full Stack Engineer

Department: Engineering

Location: Atlanta

Employment Type: FullTime

The Role

We're hiring a senior, frontend-heavy full stack engineer to design and build modern, user-friendly web applications. You'll primarily own GUI engineering (architecture, components, performance, UX), while also contributing to light backend work (API endpoints, integration logic, and troubleshooting across the stack).

This role requires a strong eye for UX: you care deeply about interaction details, consistency, usability, and accessibility—and you can turn rough requirements into a polished experience.

What You'll Work On (Day to Day)

• Lead UI feature development end-to-end: define approach, design component structure, implement flows (navigation, forms, data-heavy screens), and ship polished interactions.

• Drive UX quality: propose UX improvements, spot inconsistencies, raise the bar on micro-interactions, and ensure a cohesive experience across the product.

• Build reusable components and patterns that scale (design system contributions, shared utilities, consistent UX).

• Integrate with APIs (REST + RPC/typed APIs such as tRPC): loading states, error handling, caching, retries, pagination, and optimistic updates where appropriate.

• Own client-side state strategy (local vs server state, derived state, performance considerations).

• Ensure quality and reliability with automated tests, code review, and strong typing.

• Own UI performance and accessibility: responsive design, a11y best practices, rendering performance, and maintainable styling.

Full-stack (Light) Contributions:

• Implement or extend API routes/procedures and input validation.

• Work with authentication/session concepts and authorization-aware UX.

• Debug issues spanning frontend ↔ backend ↔ network.

Senior-level Impact:

• Mentor engineers, set patterns, and improve team velocity through thoughtful reviews and documentation.

• Identify and execute refactors that improve maintainability without disrupting delivery.

• Partner with design/PM/engineering to clarify requirements and deliver iteratively.

Must-Have Qualifications

• Strong experience building production web UIs with a modern component-based framework (e.g., React).

• Excellent UX judgment: you can spot issues in flows and visual hierarchy, and you sweat the details (usability, consistency, accessibility).

• Strong TypeScript/JavaScript fundamentals (types, async, functional patterns, maintainable code).

• Solid API integration skills: request/response modeling, error handling, caching strategies, and secure client behavior.

• Comfort with frontend architecture: routing, shared component libraries, state patterns, and incremental refactors.

• Testing mindset: ability to write and maintain unit/integration tests and prevent regressions.

• Pragmatic full-stack ability: comfortable reading and making small changes in backend code to support frontend features.

• Advanced knowledge of AI tooling: Cursor, Claude Code, Codex

Nice-to-Have

• Experience building or maintaining a design system or reusable UI component library.

• Familiarity with auth flows (SSO/OIDC, token/session handling) and role/permission-based experiences.

• Experience with real-time features (websockets/streaming) and event-driven UI.

• Basic database familiarity and understanding of how APIs interact with persistence layers.

• Strong product sense: ability to translate ambiguous requirements into clear UX and iterative delivery.

Tech Stack

Frontend: React, TypeScript, Vite, Styled Components, Tailwind CSS, TanStack Router, TanStack React Query, tRPC, Zod, Zustand.

Quality/tooling: Vitest, ESLint, Prettier.

Backend (light): Node.js, TypeScript, Express, tRPC, sessions/auth middleware, websockets.

Data (as needed): Postgres, Kysely, Drizzle (or similar query builder/ORM)

What Success Looks Like in This Role

• You ship high-quality UI features independently, with clean architecture and excellent UX.

• You raise the bar for UX consistency, accessibility, and performance across the product.

• You improve maintainability (shared components, patterns, tests) while keeping delivery moving.

• You can deliver small cross-cutting improvements that span UI, API integration, and backend support.