Senior Full-Stack Engineer

Senior Full-Stack Engineer

Start Date : As soon as possible, but open to discussion

Type: Full-time

Reports to: Bennett Brown, Head of Engineering

Compensation: $100,000-$110,000

About Us

de Anda Capital is an independent sponsor and family office with over 140 deals and over 3 billion USD in investor value creation. We are based in Los Angeles, California and New York City, New York. Our main office is located in New York City.

We acquire, operate and consolidate businesses in property management and real estate services. We work across several verticals, including property management, payroll and payments, decarbonization, manufacturing, and lending and financing.

About the Role

de Anda Capital is hiring a Full-Stack Engineer for one of our portfolio companies in the fintech space. The company is a multi-tenant time-and-attendance platform sold alongside payroll providers. It captures punches (web, kiosk with PIN, geofenced), pairs them into shifts, runs them through a configurable calculation engine (pay codes, overtime thresholds, meal and break rules), surfaces exceptions to supervisors, routes approvals, closes pay periods, and delivers approved hours and reports to payroll. It does not compute tax or net pay.

You will own vertical slices of the platform end to end — GraphQL schema, Django services, migrations, Apollo-consuming React UI, and tests on both sides — inside a spec-driven, agent-assisted workflow. The backend is the harder half: calculation correctness, concurrency, multi-tenant isolation, and time handling are where the real work is.

Technology stack

• Frontend: TypeScript, React 18, Vite, Apollo Client with GraphQL Codegen, Tailwind and shadcn/ui, react-intl, Storybook, Jest and Testing Library, in an NX monorepo with enforced module boundaries.
• Backend: Python 3.11, Django 5, Graphene (GraphQL), PostgreSQL, Redis, Celery with Beat, Django Channels for real-time subscriptions. Domain apps cover punch pipeline, calculation, timecards, scheduling, time off, configuration, reports, multitenancy, users and auth, notifications, and integrations. Tested with pytest, factory-boy, and friends.
• Cloud: AWS provisioned with Terraform — ECS Fargate (API, Celery worker, Beat), RDS PostgreSQL, ElastiCache, ALB with blue/green deploys, S3 and CloudFront for the SPA, Secrets Manager, CloudWatch. Serverless Framework Lambdas for scheduled tasks and WebSockets. GitHub Actions for CI and deploys; Docker Compose locally; Sentry for errors.
• Dev environment is live; production infrastructure is in progress. Both hires will help take it the rest of the way.

How we build

We practice Specification Driven Development with AI coding agents doing much of the first-draft implementation. The spec is the unit of work; code is its output, and humans own correctness.

1. PRD. Product and engineering write and refine a Product Requirements Document with explicit acceptance criteria.
2. Technical Documents. The PRD is decomposed into smaller Technical Documents: schema and service design, data model changes, UI contracts, test expectations, and the repo patterns to follow.
3. Agent-driven implementation. Each Technical Document drives a coding agent (Cursor with Claude models) working against the repo's AGENTS.md conventions to produce a PR.
4. Human review. An engineer reviews every agent-authored PR against the Technical Document and acceptance criteria before merge. Tenant isolation, concurrency, timezone handling, and test quality are checked by a person, not assumed.
5. Verification. The SDET lands acceptance-criteria-mapped tests in the same milestone; nothing is done until the tests say so.

Engineers here spend more time specifying, reviewing, and hardening than typing boilerplate. Strong candidates are good at writing precise specs, directing agents, and spotting what an agent got plausibly wrong.

What you will do

• Turn refined PRDs into Technical Documents precise enough for a coding agent to implement: schema, service boundaries, data changes, acceptance criteria, and the existing repo pattern to follow.
• Direct coding agents to produce the implementation, then review their PRs line by line against the Technical Document, AGENTS.md, and acceptance criteria before merge. Catch the tenant-isolation and timezone bugs an agent will not.
• Design GraphQL schema the frontend can consume without over-fetching; keep tenant scoping as a first-class argument and index.
• Write and harden service code that holds under concurrency: idempotent enqueue to the calc queue, compare-and-swap on state transitions, Decimal arithmetic for hours and money, timezone-correct pay-period boundaries.
• Add and extend Celery tasks and Beat schedules (dispatch, delivery, reconciliation) that stay testable without a running worker.
• Bring remaining admin screens onto live GraphQL contracts.
• Keep CI honest: regression suite green, no coverage erosion.
• Deploy to dev via GitHub Actions; work with our DevOps engineer on a limited basis on Terraform and the gated prod deploy.
• Triage Sentry across the three apps and the Celery services.

Projects you would land in

1. Period close and payroll delivery — finalization, blocking-vs-warning exception gates, deliveries, post-close adjustments.
2. Calc queue completion — per-tenant concurrency caps, scope expansion, config pinning, state CAS, reaper hardening.
3. Time-off finalization into payroll — accrual ledger to delivered hours.
4. Scheduling — generate and publish from templates, conflicts, swap/claim/drop, schedule-vs-actual matching.
5. Admin: locked to live — compensation models, premiums, rates, GL mapping, export mappings, messaging.
6. Time capture — kiosk flows, geofence enforcement, device enrollment, punch verification.
7. Production readiness — supporting our DevOps engineer on prod Terraform, multi-AZ RDS, secrets rotation, environment-gated deploys.

Must have

• 3–5 years shipping production web software, with hands-on experience on both fronts: TypeScript/React and Python/Django.
• Designed and consumed GraphQL schemas in production (Graphene or equivalent; Apollo client-side), including codegen and cache behavior.
• PostgreSQL fluency: migrations against live data, composite indexes, constraints, transactions, advisory locks or equivalent concurrency controls.
• Built or maintained background job systems (Celery or equivalent): retries, idempotency, dead-lettering, periodic scheduling.
• Multi-tenant data isolation and role-based authorization as first-class design concerns.
• Correct handling of time: timezones, DST, period boundaries, Decimal hours.
• Has worked with AI coding agents on real deliverables: writes specs an agent can execute, and reviews agent output critically rather than rubber-stamping it.
• Writes tests as part of the change: Jest + Testing Library and pytest + factory-boy.
• Comfortable in Docker Compose, a pnpm/NX monorepo, and GitHub Actions.
• Reads unfamiliar code before writing new code; can cite the existing pattern being followed.

Nice to have

• Django Channels / GraphQL subscriptions; WebSocket delivery to React.
• Terraform on AWS (ECS Fargate, RDS, ElastiCache, CloudFront); Serverless Framework.
• Time and attendance, scheduling, or payroll domain: overtime rules, meal/rest compliance, pay codes, accruals, prevailing wage, certified payroll.
• JWT/TOTP authentication, rate limiting behind proxy chains, secrets rotation.
• Stripe, SendGrid, WeasyPrint, OpenAI API.
• react-intl / formatjs, Storybook-driven UI work, accessibility.
• Experience maintaining AGENTS.md-style conventions or agent tooling for a team.

Not a fit

• REST-only backgrounds with no schema-design experience.
• "Full-stack" meaning frontend plus a thin API.
• Engineers who consider a fixture-backed screen shipped.
• Someone who treats agent output as done once it compiles.
• Someone who expects infrastructure to be entirely someone else's problem; DevOps support is limited.