Senior Software Engineer - Customer Files Orchestration

Thomson Reuters; Eagan (MN); On-site; USD 140,000 - 180,000; Full time

Job summary

Thomson Reuters seeks a Senior Software Engineer for the Customer Files Orchestration service within CoCounsel Legal. You will own a critical end-to-end orchestration pipeline handling millions of customer files, ensuring durability, scalability, and reliable delivery across distributed components.

You’ll design, implement, test, and operate the service, mentor teammates, and collaborate with storage, extraction, indexing, and front-end teams.

Qualifications

• Bachelor’s or Master’s degree in Computer Science, Engineering, or related field or equivalent practical experience.
• 5+ years building production software with ownership of significant components.
• Extensive AWS and production Python experience in a Python service on AWS.
• Experience with concurrency in Python, including asyncio, GIL considerations, and robust background tasks.

Responsibilities

• Design and own the orchestration service end-to-end.
• Operate and lead on-call rotations and incident response.
• Mentor engineers through code and design reviews; drive cross-team collaboration.
• Develop and enforce API contracts, versioning, and change management.
• Architect for correctness at scale with concurrency and load in mind.

Skills

System design

Distributed systems

Code reviews

On-call

Education

Bachelor’s or Master’s in CS

Tools

AWS

Python

Job description

Senior Software Engineer - Customer Files Orchestration

CoCounsel Legal is seeking a Senior Software Engineer to help build and operate the Customer Files Orchestration Service - the system that makes a customer's own documents usable by CoCounsel Legal's agents.

Every file a customer brings to CoCounsel passes through this team: upload, storage, extraction, embedding, and indexing , orchestrated end-to-end. You make millions of customer files available to CoCounsel. Bringing a customer's content together with Thomson Reuters' world-class proprietary content and the latest frontier models - including TR's own custom large language models - is what makes our products highly differentiated and our agent experiences genuinely grounded. This team is a critical part of what makes that combination possible.

It is also, unavoidably, a hard distributed systems problem. Supporting millions of files means real engineering: dedicated workers, fair queuing so one busy customer cannot starve another, durable state, idempotent processing, and honest reasoning about consistency and delivery guarantees across systems this team does not own.

The team owns what it builds, designing, implementing, testing, deploying, scaling, and operating the service end-to-end. As a Senior Software Engineer you own a meaningful part of that service outright. You are eager to ship something you're proud of and become someone the team trusts.

Key responsibilities:

Design & Technical Ownership

Own the orchestration service end-to‑end - Take an ambiguous problem, shape it into a design, write the ADR, build it, ship it, and operate it. You and the team are accountable for the outcome, not just the pull request.

Make and defend the calls that define this domain - Where eventual consistency is safe and where only a strongly‑consistent read is correct; at‑least‑once with idempotent processing versus the real cost of exactly‑once; lease and heartbeat models for crash recovery; compare‑and‑swap state transitions across asynchronous service boundaries.

Build the queuing and flow‑control machinery - Fair queuing so one busy tenant cannot starve another, rate limiting, backpressure, circuit breaking, dead‑letter handling, and autoscaling.

Treat our APIs as a product - CoCounsel's file and workspace APIs serve a growing set of consumers beyond orchestration. Versioned contracts, documented behavior, backward compatibility, and deliberate change management are part of the work, not paperwork after it.

Design for correctness at scale, not correctness in a test - Anticipate the failure modes that only appear under concurrency and load and build systems where whole classes of bugs cannot occur rather than fixing them one at a time.

Reliability & Operations

Operate what you build - Take a primary on‑call rotation for the service, lead incident response, and drive the post‑mortem that keeps the same failure from recurring.

Make the system explain itself - Instrument and trace well enough to tell "we never notified downstream" apart from "we notified downstream too early", and to answer a customer's "where did my file go?" in minutes rather than days.

Reduce operational toil deliberately - Automate the recurring manual fix and treat a runbook step that exists only in someone's head as a defect.

Technical Leadership & Collaboration

Raise the bar around you - Mentor engineers through code review and design review. Bring positive energy to the team.

Work well across boundaries - Some stages of this pipeline are owned by other teams. Partner with the storage, extraction, indexing, connectors, and front‑end teams to ensure we all ship something great.

Fully integrate Architecture and DevOps - You are part of a team where engineers do the system design. There are no DevOps engineers because everyone is responsible for developing and operating.

Communicate trade‑offs plainly - Make the cost of correctness, the meaning of a throughput number, and the risk in a deadline legible to product partners and to your own team.

Required Qualifications:

Bachelor's or master's degree - Computer Science, Engineering, or a related field, or equivalent practical experience.

5+ years building production software - With a track record of owning significant components in systems that real customers depend on.

Extensive AWS and production Python experience - This is a Python service on AWS, and you should be able to move confidently through both the code and the infrastructure.

Concurrency in Python, and a healthy respect for how treacherous it is - You understand the GIL and what it does and does not protect you from, you have written and debugged production asyncio code, and you have been bitten by the classics: fire-and-forget tasks that swallow their own failures, blocking work smuggled onto the event loop, semaphores and pools that quietly cap throughput far below the worker count, and background tasks racing the state they are meant