Title: Backend Software Engineer (Scala/Play + Functional Scala) (Mid–Senior)
Location: Greater Boston, MA
Job Type: Contract
Duration: 6-months + potential extension
About our client
Our client builds and operates a customer identity & users microservice that powers authentication/authorization flows, user lifecycle (registration, login, profile updates, soft-delete), client configuration, and partner/POS integrations. The service is API-first, security-sensitive, and production-grade, with a strong focus on reliability, privacy, and observability.
What you’ll do
- Build and maintain REST APIs using Scala + Play Framework, with functional Scala principles (immutability, strong types, explicit error handling).
- Design and implement core identity capabilities:
- OAuth/token flows (token issuance, validation, revocation, authorization-code style flows, login/continue flows).
- User lifecycle endpoints (create/update/get/delete, password reset, email change, deletion status/bulk operations).
- Admin/internal endpoints (audit/changelog style APIs).
- POS/store-related integrations and third-party linking/redirect handlers.
- Evolve and maintain OpenAPI contracts: accurate schemas, safe versioning, backward compatibility (including legacy wrapper endpoints).
- Write and maintain automated tests (unit + integration/contract tests) for critical login/token/user flows.
- Improve operability: performance tuning, resilient error handling, careful rollout practices, and safe DB/data changes.
- Collaborate across product/security/platform teams to ensure the service remains secure, observable, and reliable in production.
- Participate in code reviews and contribute to team standards (design docs, API guidelines, coding conventions).
What we’re looking for (must-have)
- Proven experience delivering production backend services (mid–senior).
- Scala experience with a functional programming mindset, including:
- Immutable data modeling and referential transparency where practical.
- ADTs / sealed traits, pattern matching, and type-driven design.
- Clear error modeling (e.g., Either, validated inputs) and consistent domain boundaries.
- Familiarity with functional libraries and patterns (e.g., Cats; Cats Effect/ZIO is a plus).
- Experience with Play Framework (or strong Scala + a JVM web framework and ability to ramp quickly on Play).
- Strong API design skills: schema evolution, compatibility, pagination/filtering patterns, and client-friendly errors.
- Security fundamentals for identity systems: bearer tokens/JWT, basic auth use cases, CSRF considerations, and common attack vectors (enumeration, injection, replay).
- Database experience (SQL, migrations) and operational caution when changing data models.
- Strong testing practices: integration tests, contract tests, and CI stability.
Nice-to-have
- Deep OAuth2/OIDC knowledge (authorization code + PKCE, refresh tokens, token introspection/revocation).
- Experience with identity/privacy workflows (soft-delete, deletion status, consent/newsletter flags).
- Observability experience (structured logging, metrics, tracing, alerting).
- Experience maintaining legacy API compatibility and running safe migrations without downtime.
- Docker/CI/CD experience and comfort supporting production incidents.
You’ll be successful if you...
- Ship features without compromising security/privacy.
- Keep OpenAPI accurate and treat the API contract as a first-class artifact.
- Reduce regressions in critical auth/user flows through strong automated test coverage.
- Improve maintainability using functional Scala patterns (clear domain models, predictable effects, fewer side effects).
Interview focus areas
- Functional Scala design: data modeling with ADTs, error handling, and testability.
- API design and schema evolution (OpenAPI-first thinking).
- Secure implementation of token/session/CSRF-sensitive flows.
- Debugging and production triage (logs, tests, minimal repro).
- Code quality and collaboration in a microservice environment.
Tech stack (representative)
- Scala, Play Framework, sbt
- REST/OpenAPI, JSON + form-encoded endpoints
- Auth patterns: bearer JWT, basic auth (service/internal clients)
- SQL + migrations
- Docker / CI pipelines
- Observability tooling (logs/metrics/tracing)
