Principal Software Engineer, AlphaSense

• Deep hands-on architecture experience in large microservice estates, at least in hundreds
• Strong in Java and Python, and willing to contribute to other tech stacks if needed
• Track record decomposing large service estates into sub-systems that can evolve independently
• Proven experience designing for horizontal scalability across regions and independent deployments
• Experience with cell-based, multi-tenant or multi-region architectures
• Strong cloud-native background: Kubernetes, containers and AWS
• Experience externalising configuration and removing environment coupling from application code
• Demonstrated ability to land significant changes in code owned by other teams
• A record of spotting architectural limits before they turn into incidents
• Ability and desire to design, lead, influence and deliver on ambitious technical roadmaps

Desirable

• AlphaSense runs a large-scale, Kubernetes-native platform built on a modern microservices architecture, serving the majority of the Fortune 500
• We're now moving it into a cell-based architecture, where each cell is an independent deployment of the platform, and the cell count is heading from dozens toward hundreds, including private and isolated clouds
• Platform tooling only takes that so far
• The rest of the problem is architectural and it sits in the services: how they're structured, how they're bounded, and what they assume about the environment they run in
• This role owns that side of the work
• You'll set the architectural direction for how our services scale horizontally across regions, cells and deployment models, and you'll build it rather than specify it
• You'll own the environments configuration management framework to operate environments as a fleet, and the services and libraries to make it work
• Where the answer is a re-architecture rather than a patch, you design it and you write it
• Much of it lands in code other teams own, so influence matters as much as design
• The scope is deliberately broad: hundreds of services, several languages, and the latitude to go after whichever scalability limit matters most
• Our main languages are Java, Python, React and Rust
• We use AI tooling heavily and expect the same from you, along with a view on how the rest of engineering should be using it
• Drive the service-side changes cell architecture needs: re-architecture, shared library, etc
• Decompose hundreds of microservices into sub-systems with independent lifecycles
• Find and close horizontal scalability gaps across regions, cells and deployment models
• Own the environments application configuration management framework end-to-end
• Own the services and libraries specific to private and isolated cloud deployments
• Design and land changes directly in product services, partnering with the teams that own them
• Set the architecture patterns and reference implementations product teams build against
• Make configuration a runtime concern rather than something baked into service code
• Partner with Cloud Platform, SRE and DevEx on where the service and platform boundary should sit
• Raise the architectural bar across the org and mentor Staff and Senior engineers
• Embed AI tooling into day-to-day development for lasting productivity gains