Principal Software Engineering - Rust Systems Engineer

We are Progress (Nasdaq: PRGS), a trusted provider of software that enables customers to develop, deploy and manage responsible, AI‑powered applications and experiences with agility and ease. We’re proud to have a diverse, global team that values individual perspectives. This hybrid role in Burlington, MA requires candidates to be local and does not offer relocation.

We are at a strategic inflection point: selectively introducing Rust into the 30‑year‑old Open Edge database engine to improve memory safety, unlock new platforms, and build modern subsystems. You will serve as the Rust technical lead across multiple sub‑teams and found the Rust Guild.

• Rust Platform & Build Integration
  • Integrate Cargo‑based workflows into the existing CMK build system so Rust shared libraries compile, link and ship alongside 200+ C subsystems on Linux  and Windows 64‑bit.
  • Define and standardize RustC FFI architecture, including extern "C" boundary design, auto‑generated C headers (via cbindgen), error‑handling conventions and memory ownership rules.
  • Establish Rust as a first‑class, supportable language within the core database engine.
• Core Systems Libraries
  • Design production‑grade Rust shared libraries to replace legacy C implementations for compression (zstd), JSON parsing () and Avro serialization.
  • Own benchmarking, validation and parity testing to ensure performance and stability match or exceed legacy code.
• Platform & Architecture Leadership
  • Architect a Rust‑based platform systems layer to replace System V IPC with modern cross‑platform primitives.
  • Enable macOS developer builds and ARM/Graviton production deployments.
  • Design NUMA‑aware memory allocation strategies for multi‑socket servers using hwloc.
  • Guide Tier‑3 Rust crates covering cloud file I/O, Iceberg table operations and engine integration bridges.
• Async & Networking Modernization
  • Architect an async gRPC server using tonic, tower and tokio to modernize the PASOE data path and replace Tomcat/HTTP flows.
  • Design middleware layers for authentication (JWT), observability and performance isolation with a focus on multi‑throughput improvements.
• Engineering Enablement & Code Quality
  • Act as the Rust code owner: review PRs and enforce idiomatic Rust, safe unsafe usage, consistent FFI patterns.
  • Mentor senior C/C++ engineers transitioning to Rust through pair programming, structured code reviews and module translation exercises.
• Community, Leadership & Communication
  • Lead the Rust Guild, hosting sessions covering FFI design patterns, async Rust and architectural deep dives.
  • Communicate decisions, trade‑offs and migration strategy to senior leadership and cross‑functional stakeholders.
  • Partner with management on Rust adoption standards, long‑term platform strategy and hiring plans.

• 10+ years of software engineering experience, including 5+ years of production Rust in systems‑level software.
• Strong C/C++ background; able to read and interface with 10,000+ C files daily.
• Expertise in RustC FFI, including extern "C", cbindgen/bindgen, unsafe boundary design and memory‑ownership protocols.
• Experience shipping shared libraries (.so/.dll) consumed by C/C++ callers in production.
• Experience integrating Cargo with non‑Cargo build systems (Make, CMake, Bazel, custom).
• Multi‑platform development on Linux  and Windows 64‑bit.
• Knowledge of OS fundamentals: file‑system, storage, memory, virtual memory, process synchronization and multithreading.
• Strong problem analysis and independent execution under tight deadlines.
• Excellent verbal and written communication in English.
• Mentorship/tech‑lead experience; will train a team.
• Bachelor’s in Computer Science or equivalent foundation in data structures, algorithms, operating systems and databases.

• Experience with database internals such as shared memory, buffer pools, WAL and concurrency control.
• Production experience building async gRPC services in Rust (tonic, tower, prost).
• Familiarity with Apache Arrow, Parquet, Iceberg and Avro ecosystems.
• NUMA‑aware programming with hwloc, mbind,  and per‑node allocation strategies.
• Memory allocator design,…