Senior Software Engineer- Rust / C++

Responsibilities

You will lead the design and development of a high-volume, queue-driven document processing pipeline using Rust and C#/.NET. Additionally, you will mentor team members, set technical standards, and own the end-to-end production lifecycle of services on Azure.

Requirements

Candidates must have 7+ years of professional software development experience in backend services using Rust or C++. Deep expertise in distributed systems, performance optimization, and a track record of leading complex technical projects are required.

Skills

• Rust
• C++
• C#
• .NET
• Distributed systems
• Azure
• Kubernetes
• System architecture
• Performance profiling
• Load testing
• Message queues
• CI/CD
• Mentoring
• Technical writing
• Agentic development
• API design

Benefits

• Flexible vacation
• Mental health days
• Headspace app access
• Retirement savings
• Tuition reimbursement
• Employee incentive programs
• Health insurance
• Dental insurance
• Vision insurance
• Disability insurance
• Life insurance
• 401k plan
• Parental leave
• Sabbatical leave
• Fitness reimbursement
• Employee assistance program
• Commuter benefits
• Adoption and surrogacy assistance
• Employee stock purchase plan

About this role

Job Description:

Thomson Reuters is hiring Senior Software Engineers to build the core of the document-processing platform behind our AI products. The platform turns very large volumes of documents, millions of pages a day, into clean, structured output through a queue-driven pipeline. It powers flagship products like Westlaw and CoCounsel and serves internal product teams across the company. The work is mostly Rust in DU Core, with regular work in the C#/.NET services (DU Apps) that sit in front of it. As a Senior Software Engineer II, you’ll lead high-impact projects across Core and Apps, shape how the platform evolves, and set the technical bar for the team.

Key Responsibilities:
Turn asks into requirements. Take requirements from product owners and consuming teams, and propose your own improvements. Turn them into clear functional and technical requirements: the problem, who is asking, how much traffic it affects, acceptance criteria, non-goals, and how we’ll know it worked
Design with explicit trade-offs. Write design docs and ADRs that include all the options considered and why the chosen solution won out. Cover cost, latency, quality, failure modes, operability and security, not just the happy path.
Define the architecture. Shape how our services are designed, deployed and run on Azure, and decide where the boundaries between services belong.
Find and fix bottlenecks. Use production metrics, profiling, latency distributions and traffic mix to find where the pipeline is slow or wasteful, and to set timeouts, limits, concurrency and rollout plans. Back decisions with benchmarks and load tests, and be clear about what the results do and don’t show.
Build and run the processing pipeline end to end. It’s a queue-driven pipeline that handles millions of pages per day. That means autoscaling, rate limiting, retries and failover across third-party vendors, very large inputs, and streaming with bounded memory while minimizing latency and maximizing throughput.
Work across Core and Apps. You’ll likely spend most of your time in the core backend Rust services, but be willing to pivot to C#/.NET to support the customer-facing services that sit in front of them.
Evolve contracts safely. Change message schemas, API surfaces and feature flags across services, and often across repos, in one coordinated change. Internal product teams depend on our output, so keep changes additive and backward compatible, ship with a rollout and rollback plan that covers every side, and return errors that consumers can act on.
Keep a strong engineering mindset. Prefer simple designs over convoluted ones, deliver in small reviewable steps, test at the right layers, and leave code better than you found it.
Work agentically. Write specs and plans that coding agents can carry out, break work into reviewable pieces, and check agent output with tests and evidence. Evaluate AI tools for specific use cases. You own the correctness every line you merge, whoever or whatever wrote it.
Improve how humans and agents work here. Evolve our agent instructions, skills and review automation so they capture what the team knows, and measure whether they help. Write code, docs and PRs clear enough that a new teammate and an AI agent can both understand the intent, constraints and invariants.
Own it in production. Instrument services so you can see how they behave, take part in the on-call rotation and incident response, write blameless postmortems, and turn what you learn into lasting fixes.
Lead high-impact work. Own the design and rollout of large projects from requirements through production, break
them into pieces the team can deliver, and keep the vision for where they’re headed.
Raise the team’s bar. Mentor engineers and set the standard in code and design review.
Influence direction. Translate business needs into technical solutions, explain hard trade-offs to technical and non-technical audiences, and shape product and platform decisions with consuming teams and leadership

Required Qualifications:
7+ years of professional software development experience building and operating backend services in production in Rust or C++. If your background is C++, you should be keen to work in Rust day to day.
Experience leading complex projects across teams, including architecture for multi-region or highly available systems.
Experience designing features with privacy and compliance requirements in mind, and building those requirements into code.
Deep distributed-systems expertise: message queues and at-least-once delivery, idempotency, backpressure, retries and timeouts, failure detection, and autoscaling.
Experience choosing between storage options (relational, NoSQL and others) for a given workload.
A record of performance work at scale: profiling, benchmarking, memory budgets, concurrency limits, and handling inputs that don’t fit in memory
A track record of written design work (design docs, ADRs or RFCs) that compared options and drove a decision, and of turning ambiguous asks into scoped, testable requirements.
Excellent software development fundamentals: testing strategy across unit, integration and load, security-conscious defaults, and incremental delivery through CI/CD.
Experience mentoring other engineers, and strong code-review and technical-writing skills.
Hands-on experience with agentic development (e.g., Claude Code, Cursor, GitHub Copilot).
Ownership mindset: you follow your work into production, lead root-cause analysis, and fix what you find
Willingness to join the team’s on-call rotation.
Willingness to work in C#/.NET, and to learn it if you don’t already know it.
Must be located in the United States.
Must be a U.S. Person and legally authorized to work in the United States without current or future visasponsorship.

Preferred qualifications:
Professional experience with Rust: async (Tokio), errors modeled as types, and performance and memory tuning.
Daily, critical use of AI coding agents, including knowing when not...

About Thomson Reuters

Software Development · 10,001+ employees · headquartered in Toronto, ON