Olive Jobs
Midjourney logo

Principal Software Engineer

Midjourney

San Francisco, CAFull-timeNo compensation foundPosted 1mo agoVerified open 6 days ago
Evaluate my fit

Most applications go out cold — see where you stand first. No sign-up to start.

Don't just apply. Show up ready.

Olive works from this exact posting — no sign-up to start.

Evaluate your fitSee where you stand — strengths, gaps, and what to fix first.Get started →Tailor your résuméRewritten against this posting, with a diff of every change.Get started →Practice the interviewA voice mock interview built from this job description.Get started →

At a glance

Compensation
No compensation found
Location
San Francisco, CA
Schedule
Full-time
Work Authorization
Not specified

Job overview

Midjourney is hiring a Principal Software Engineer. Midjourney is seeking a Principal Software Engineer to lead the technical direction for significant parts of its scanner platform, focusing on system architecture, codebase structure, and long-term maintainability. This role involves owning core runtime foundations, driving engineering rigor, and building robust observability. The engineer will collaborate with hardware and ML teams to define interfaces and lead complex refactors.

Key focus areas include Act as the technical lead for large parts of the scanner platform, Own core runtime foundations, and Drive engineering rigor.

Successful candidates bring Deep Software Architecture Experience For Real-World Systems and Track Record Of Shipping Observable Systems. Important skills include System Architecture, Codebase Structure, Long-Term Maintainability, Distributed Control, State Management, and Fault Handling. Preferred (not required): Clear Interfaces, GRPC/Protobuf, Strong State Modeling, and Failure Handling.

Skills & qualifications

RequiredNice to have

Skills

System ArchitectureCodebase StructureLong-Term MaintainabilityDistributed ControlState ManagementFault HandlingReliabilityTestabilityCode QualityReview StandardsPerformance Regression PreventionRelease ProcessesObservabilityLoggingMetricsTracesReplayable DiagnosticsDefining InterfacesData ContractsTiming/SynchronizationFailure ModesComplex RefactorsMessage PassingRPC BoundariesModularizationConcurrency ModelPythonConcurrency BackgroundAsyncioMultiprocessingProfilingPerformance EngineeringTechnical LeadershipClarityPragmatic Trade-OffsCoachingClear InterfacesGRPC/ProtobufStrong State ModelingFailure HandlingGood TestsCIReproducible Dev EnvironmentsFast Code ReviewPractical PerformanceDebugging Distributed BehaviorSecurity-Minded Device SoftwareSafe DefaultsEncrypted Data PathsDisciplined Handling of PII/PHI

Qualifications

Deep Software Architecture Experience for Real-World SystemsTrack Record of Shipping Observable Systems

Full job description

WHAT YOU’LL DO

  1. Act as the technical lead for large parts of the scanner platform: system architecture, codebase structure, and long-term maintainability.

  2. Own core runtime foundations: distributed control, state management, fault handling, and reliability.

  3. Drive engineering rigor: testability, code quality, review standards, performance regression prevention, and release processes.

  4. Build robust observability: logs, metrics, traces, and replayable diagnostics (with privacy constraints).

  5. Collaborate with hardware and recon/ML teams to define interfaces, data contracts, timing/synchronization, and failure modes.

  6. Lead complex refactors (e.g., message passing / RPC boundaries, modularization, concurrency model) without halting forward progress.

WHAT WE’RE LOOKING FOR

  • Deep software architecture experience for real-world systems: robotics, instrumentation, medical devices, or other complex distributed products.

  • Strong Python and concurrency background (asyncio, multiprocessing, profiling, performance engineering).

  • Track record of shipping systems that are observable, debuggable, and resilient.

  • Strong technical leadership: clarity, pragmatic trade-offs, and mentoring.

USEFUL EXPERIENCE

  • Building but rock-solid systems: clear interfaces (gRPC/protobuf or equivalent), strong state modeling, and failure handling.

  • High-leverage engineering habits on a lean team: good tests, CI, reproducible dev environments, and fast code review.

  • Practical performance + concurrency work in Python (asyncio, profiling, multiprocessing) and comfort debugging distributed behavior.

  • Security-minded device software: safe defaults, encrypted data paths, and disciplined handling of PII/PHI.

  • Operational thinking: remote updates/management, excellent logging, and diagnostics that make real hardware debuggable.

You've read the whole posting — now see how you match it.

Evaluate my fit