Senior Full-Stack Engineer

The Full Stack Engineer builds and runs the digital surfaces the Commercial STO puts in front of Expereo’s Customers as well as Commercial and Service Preparation teams, front to back: the React front ends, the service layer those front ends consume, and the integrations that connect them to Salesforce and the wider systems landscape.

You will join the Commercial STO, the technology team that owns the systems behind how Expereo quotes, orders, and activates services. A central part of that work is expereoOneNext, the platform that moves request intake, site creation, quoting, order placement, and service activation out of inboxes and spreadsheets and into one place. It is live with its first users and growing, and you will carry features on it from the first conversation with the people who use it to the release that reaches them.

This is a hands-on engineering role with a front-end center of gravity and full-stack reach. You are strongest in React and TypeScript, fluent in the Node.js layer between the browser and the backend, and able to deliver a feature end-to-end, including the service and integration parts. You will read and work in C#/.NET at the integration points with the systems around the platform. You own what you ship, in production, and you are the engineer others on the team rely on to get it right.

Key Responsibilities

Front-end delivery

• Own the React and TypeScript front ends of the surfaces you work on, from component structure and state management to data fetching, caching, and performance.
• Turn requirements from commercial and operations users into production-quality experiences that make their daily work faster and less error-prone.
• Keep the front-end codebase coherent as it grows: shared components, consistent patterns, and a design language that holds across screens.
• Bring the consumer’s view into API design: what the interface needs to look like for the front end to be simple, fast, and correct.

End-to-end feature delivery

• Implement the service layer each feature needs, REST or GraphQL, working contract-first from OpenAPI specifications.
• Build and maintain the integrations with Salesforce and other core systems that commercial data flows through, so that what a user enters on the platform arrives correctly where it is needed downstream.
• Implement authentication and authorization for the features you build, so access is secure by default rather than by exception.
• Keep the interfaces you introduce versioned and backward-compatible; downstream consumers are never broken silently.
• Read and work at the C#/.NET integration points with the wider systems landscape when a feature crosses them.

Delivery and operations

• Own the delivery path for what you ship: configure, deploy, observe, and operate your own surfaces on a managed cloud (AWS), working with the team’s DevOps engineers on the shared pipeline rather than waiting on it.
• Use feature flags as the delivery mechanism: ship behind a default-off flag, prove with real use, remove the flag last.
• Write tests that give real confidence, not coverage numbers, and drive automated quality gates in CI.
• Diagnose and resolve production issues on the surfaces you own, so the order and activation flows commercial teams depend on keep working.
• Maintain living technical documentation: API specs, architecture decision records, and integration guides that let another engineer pick the work up.

Collaboration

• Work directly with product owners, quote management, service operations, the architect in the Innovation team, and the other engineering teams whose systems the platform connects to.
• Translate technical constraints and design decisions into plain language for commercial and operations stakeholders.
• Participate in design reviews, sprint reviews, and technical decision-making; propose approaches and flag risks early.
• Raise the bar through code review, example implementations, and clear written reasoning about trade-offs, and help onboard other engineers onto the codebase.

Requirements Must have

• Five plus years of professional software engineering, with production React and TypeScript front ends as your core stack.
• Node.js and TypeScript services in production, and comfort implementing the layer between the front end and the backend for the features you own.
• REST and/or GraphQL APIs implemented and consumed in production, with contract-first OpenAPI as a working method.
• Ownership of the delivery path for what you ship: you configure, deploy, observe, and operate your own work on a managed cloud, with CI/CD as part of how you work rather than someone else’s job.
• Software engineering discipline: testing, code review, Git, feature flags, and reproducible builds. You build things other people can maintain.
• Ability to work in a mixed-language environment. The systems around the platform include C#/.NET. You do not need to be expert in it, but you need to read it, understand the integration points, and be willing to write in it.

Strong nice to have

• Integration experience with Salesforce, including data models, APIs, and keeping two systems consistent.
• AWS services in practice: Amplify, Lambda, API Gateway, Cognito, S3, or equivalent.
• OAuth2 and OIDC in practice (Cognito, Okta, or equivalent), including scope models and token lifecycle.
• C#/.NET backend exposure, enough to contribute at the integration points.
• Event-driven or asynchronous integration: queues, SQS, EventBridge, Kafka, or similar.
• Front-end architecture beyond a single application: micro front ends, module federation, or comparable patterns.

Also welcome, not required

• Experience with DDD, CQS, or event-driven architectural patterns.
• Comfort producing C4 diagrams, ADRs, and integration guides.
• Experience building internal tools for sales, quoting, or order management teams.
• Connectivity, SD-WAN, SASE, or network platform domain background. Not required; useful if you have it.

Collaboration and mindset

• Product-minded: you think about the person on the other side of the screen, not just the endpoint behind it.
• End-to-end ownership: you would rather carry a feature from the first component to the last deployment than hand it off halfway.
• Reliability matters to you: the people using what you build depend on it to do their jobs.
• Prefer building the right thing simply over building the perfect thing slowly.
• Contract-first is a value, not just a technique.
• Curious across the stack: the boundaries of your role are set by what the feature needs, not by the language you started in.

Benefits

• Part of a team that is engaged and owning the things they do, highly trustable with direct commercial stakes.
• Direct access to production systems, real data, and decision-makers - no layers of process between your work and its impact.
• Exposure to cutting-edge technologies and large-scale global networks.
• A role designed with trajectory in mind - the knowledge you build here is directly applicable to a senior technical execution path.
• Competitive compensation and local benefits
• Hybrid Working

Beyond the Job

We’re proud of our focus on as Environment, Social and Governance as well as the passion we display for the communities where we live and work.

EEO (Equal Employments Opportunities) Statement

Expereo is an Equal Opportunities employer who aims to support and celebrate every employee that comes through our doors. We respect and support all of our people regardless of background, religion, nationality, sexual orientation, age, or physical condition.