Senior Software Engineer - Polyglot

Overview Of 73 Strings 73 Strings is an innovative platform providing comprehensive data extraction, monitoring, and valuation solutions for the private capital industry. The company’s AI-powered platform streamlines middle-office processes for alternative investments, enabling seamless data structuring and standardization, monitoring, and fair value estimation at the click of a button. 73 Strings serves clients globally across various strategies, including Private Equity, Growth Equity, Venture Capital, Infrastructure and Private Credit.

Our 2025 $55M Series B, the largest in the industry, was led by Goldman Sachs, with participation from Golub Capital and Hamilton Lane, with continued support from Blackstone, Fidelity International Strategic Ventures and Broadhaven Ventures.

Role Summary

We’re looking for a Senior Software Engineer to own the integration layer of our platform: the services that pull market data, FX rates, and client data into 73 Strings, and the APIs that expose our data back out to clients and their systems.

This is the surface where our platform meets everyone else’s. Third-party feeds change format without warning, client APIs behave differently from their documentation, and a valuation that arrives late or with a stale FX rate is a real problem for a real investment committee. You’ll build services that hold up under that, and you’ll own them from the first commit through to running them on Kubernetes.

It’s a hands-on senior role for someone who moves without being pushed. You’ll work closely with Data Engineering, Product Management, and the product verticals, and you’ll be expected to challenge an integration design or an API contract that won’t survive contact with production.

What You’ll Own

Third-Party and Market Data Integrations

• Own our integrations with market data and reference data providers, FX and currency sources, and the financial data vendors our valuation and monitoring products depend on.
• Design ingestion services that treat vendor unreliability as normal: rate limits, partial responses, schema changes, retries, idempotency, and sensible degradation when a feed goes down.
• Own correctness at the boundary. Validate what arrives, reconcile against expectations, and make sure a bad upstream payload fails loudly instead of quietly polluting downstream data.
• Build the integrations as reusable patterns rather than one-off adapters, so the fifth provider takes days rather than the same weeks as the first.

Client API Integrations and Data-Out APIs

• Build and own the integrations that connect 73 Strings to client systems, including their internal APIs, file-based exchanges, and third-party platforms in their stack.
• Design and deliver the APIs through which we expose our data to clients: clear contracts, versioning, pagination, authentication, and authorization that stands up to enterprise security review.
• Make those APIs genuinely performant. Understand the query patterns behind each endpoint, and design for the payload sizes our largest clients actually request.
• Own the interface contract over time: deprecation as a planned event, backwards compatibility as a default, and breaking changes as a deliberate, communicated decision.

Service Ownership, End to End

• Own your services from code to production: design, implementation, tests, CI/CD, deployment on Kubernetes, configuration, and rollback.
• Instrument what you build. Metrics, structured logs, traces, dashboards, and alerts that let you or an on-call engineer diagnose an issue without reading the source.
• Define and meet SLOs for the services you own, and be honest about where the current design is a risk.
• Take part in on-call for your services, and close incidents with a fix that prevents the next one rather than a note in a document.
• Manage the cost and resource footprint of your services alongside their performance.

Performance and Reliability

• Treat performance and reliability as requirements, not as a later optimization pass. Know the latency and throughput profile of your services and where they break.
• Profile before optimizing. Find the actual bottleneck, whether it’s a query plan, a serialization cost, a chatty call pattern, or a thread pool.
• Design for failure modes you can name: timeouts, backpressure, circuit breaking, bulkheads, and graceful degradation under load.
• Reduce complexity and technical debt where it threat…