Remote FullStack Developer | 6-10 yrs ex | W-2 Only | MA/NY area

< dir=ltr>Core Responsibilities

• Build and own full vertical slices of the product: React components, TypeScript interfaces, RTK Query endpoints, Node.js/Express handlers, etc. within the same feature.

• Design shared component and API patterns that other stories consume — not just implementing your own tickets but considering how the building blocks you create will be used across the feature.

• Participate actively in sprint planning and backlog refinement; push back on stories that lack sufficient design or data specification before they enter a sprint.

• Write behavioral tests (Vitest + React Testing Library) alongside implementation; not as a separate phase.

• Identify and document reuse opportunities across implementation areas — patterns and observations that prevent duplicate work by teammates.

• Contribute to technical design decisions: endpoint shape, permission resolution strategy, caching approach, component API design.

< dir=ltr>Required Skills and Experience

TypeScript and React (Non-Negotiable)

• 5+ years of professional React development; 3+ years using TypeScript in a production React codebase — not just annotating JS, but designing typed data contracts, discriminated unions, and generic component interfaces.

• Strong understanding of React 18 patterns: functional components, custom hooks, memo/useCallback usage, Suspense and lazy loading.

• Practical experience with Redux Toolkit and RTK Query: defining API slices, managing loading/error states, understanding caching and cache invalidation behavior. Experience with Redux middleware or Thunks is useful but secondary to RTK Query fluency.

• Form handling with react-hook-form and schema-based validation (Yup or Zod). Comfort with multi-step forms, conditional field logic, and controlled vs. uncontrolled patterns.

• Familiarity with design system libraries coupled with the ability to read component documentation and use the provided components correctly without reaching for custom solutions.

< dir=ltr>Node.js API Development

• 3+ years building and maintaining REST APIs with Node.js and Express (or equivalent framework). The ability to design endpoint shapes that are efficient to consume from the client and that handle partial failures gracefully.

• Experience integrating with external APIs or SaaS platforms — writing against third-party REST or SOAP interfaces, handling pagination, rate limiting, and API version differences.

• Working knowledge of authentication middleware: JWT validation, token refresh patterns, understanding of OAuth 2.0 / OIDC flows even if you have not built them from scratch.

• Comfort with Redis for caching: setting TTLs, invalidation strategies, understanding when caching introduces staleness risk.

< dir=ltr>Testing Discipline

• Writes tests as part of implementation, not after. Can articulate the difference between testing behavior and testing implementation details.

• Experience with React Testing Library (or equivalent) — tests that simulate user interactions and assert on visible output, not on component internals.

• Able to write meaningful tests for async behavior (loading states, API responses, error boundaries) using mocked service layers.

< dir=ltr>Communication and Collaboration

• Comfortable working from incomplete specifications. This codebase has documented open questions and known design ambiguities. You should be able to make reasonable implementation decisions while flagging assumptions clearly, rather than blocking on every undefined detail.

• Can write clearly about technical decisions — not lengthy documents, but precise comments, PR descriptions, and notes that explain why a non-obvious choice was made.

• Experience working in a two-week sprint cadence with regular demos and code review.

< dir=ltr>Preferred Experience

The items below are meaningful advantages, not requirements. Strong candidates who lack one or two of these areas but demonstrate strong fundamentals will be considered.

Salesforce Integration

Experience querying Salesforce APIs — REST, SOQL, or the Composite REST API — from a Node.js service layer. Familiarity with Salesforce object relationships, governor limits, and the operational constraints of building against a shared Salesforce org. This is the hardest skill to hire for and the one most directly relevant to the near-term work — candidates with it will ramp faster on the Salesforce integration stories.

< dir=ltr>Salesforce Financial Services Cloud (FSC)

Awareness of FSC-specific objects (FinancialAccount, FinancialAccountParty, FinancialAccountTransaction) and the patterns around financial planning data in Salesforce. This is uncommon and not expected; it is worth calling out because it maps directly to the data model being built against.

< dir=ltr>Configuration-Driven UI Patterns

Experience building UIs where behavior (form fields, visible actions, permission rules) is driven by JSON configuration or metadata rather than hardcoded logic. This pattern is central to how the Plan Actions dropdown and form workflows are architected in this codebase.

< dir=ltr>Authentication and Identity

Production experience with Okta — specifically the Okta React SDK and its interaction with protected routes, token management, and user profile claims. Understanding of how identity provider tokens flow through to API authorization.

< dir=ltr>Event-Driven Systems

Exposure to Apache Kafka or a comparable message broker — consuming events from a topic, understanding at-least-once delivery, schema registry basics. Kafka is used for plan status notifications and data synchronization in this system; most of the Plan Detail work does not touch it directly, but familiarity is useful for understanding the broader system.

< dir=ltr>Financial Services Domain

Understanding of concepts like financial plan administration, fee allocation, advisor-client relationships, or fiduciary workflows. Domain knowledge reduces the time required to understand why certain data models exist and what edge cases matter to users. It is not expected but meaningfully shortens onboarding.

< dir=ltr>Python API Development

Production experience building REST APIs in Python using FastAPI, Flask, or Django REST Framework. Comfort with async patterns (async/await in FastAPI or equivalent), request validation, and structuring a Python service for maintainability alongside a Node.js-heavy ecosystem.

< dir=ltr>Data Manipulation and ETL

Hands-on experience using Python for data transformation work — pandas, SQLAlchemy, or similar libraries — particularly in the context of moving or reshaping data between systems (ETL pipelines, data migration scripts, or integration utilities). Familiarity with writing repeatable, auditable data workflows is a plus given the system-of-record nature of the platform.

< dir=ltr>Accessibility

Working knowledge of WCAG 2.1 AA compliance — aria attributes, keyboard navigation, screen reader behavior. Blueprint components handle much of this, but custom compositions still require accessibility-aware implementation.

< dir=ltr>Experience Level Calibration

This role targets a senior individual contributor. The following describes what that means in practice for this position:

You are likely a strong fit if:

• You have built and shipped complex, multi-section single-page applications with non-trivial state management and real production traffic.

• You have made architectural decisions at the component or API layer level — not just implemented tickets, but contributed to how a feature was structured.

• You can look at an implementation notes document or a Figma design and independently identify risks, ambiguities, and reuse opportunities before writing a line of code.

• You have debugged integration failures between a frontend application and a third-party API, including cases where the problem was in the API contract rather than either side''''''''s implementation.

• You are uncomfortable shipping code you don''''''''t understand, and you push back on timelines when the specifications needed to build correctly haven''''''''t been answered.

This role is probably not the right fit if:

• You need a senior engineer to define the TypeScript interfaces before you can begin component work.

• You rely primarily on one layer (FE or BE) and treat the other as a support dependency.

• You prefer a codebase where patterns are fully established and the work is primarily applying existing approaches to new screens.

Typical background: 6–10 years of professional software development, with the last 3–5 years in senior or lead individual contributor roles on production web applications. Years are indicative, not a filter — the calibration above is what matters.