Wehi Augustoff

Backend • Senior • 26 years • Yerevan, Armenia • UTC+04:00 • Remote/Hybrid • Relocation • Work permits: Russia, Armenia • Available in 1 week • from $30k per year
Software Developer
1+ project
Python
Rust
SQL
C++
JavaScript
Lua
C
Go
Data Layer & Database: 8/10
Scalability & Performance: 7/10
System Architecture: 7/10
Active 22 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles

Overview

A senior-level distributed-systems backend engineer who builds real-time, sharded push infrastructure using Rust (with a complementary Go jobs tool). The strongest proven skill is designing DB-driven coordination for messaging - evidenced by the Store layer using FoundationDB transactions, versionstamped keys and shard-watch/drain logic in src/store.rs and the pusher components. There is limited public evidence of production auth/token management, secrets handling, formal API versioning, or extensive operational runbooks and SLO/monitoring artefacts.

Technical skills

Python
Rust• Senior
SQL
C++
JavaScript
Lua
C
Go• Senior • 3y+
Rust
Tokio
Axum
Serde
Anyhow
Tracing
Reqwest
Databases
Apache Kafka
PostgreSQL
Databases
FoundationDB• 1 project
DevOps
Docker
Git
gRPC
Rest API
WebSockets
Frontend
GraphQL• 3y+

Timeline

Software Developer • Middle
Cloud.ru • Full-Time
Apr 2023 to May 2025 2 Years 1 Month Moscow Remote/Hybrid
Started as an intern and was promoted to a middle software engineer while working across multiple teams. Rewrote services from TypeScript to Go to improve observability and performance, and shipped production services including STT and an AI chat feature. Built internal platform capabilities such as integration libraries for CMDB, an API management service, and automation for technical support via Telegram, including an FSM implementation covered by tests. In the DSWorks team, maintained a monolithic application with many database migrations, used Hasura for GraphQL delivery, and developed automated integration tests with fixtures.
Go
GraphQL
Senior Backend Developer Confidence: High Distributed Systems
A senior-level distributed-systems backend engineer who builds real-time, sharded push infrastructure using Rust (with a complementary Go jobs tool). The strongest proven skill is designing DB-driven coordination for messaging - evidenced by the Store layer using FoundationDB transactions, versionstamped keys and shard-watch/drain logic in src/store.rs and the pusher components. There is limited public evidence of production auth/token management, secrets handling, formal API versioning, or extensive operational runbooks and SLO/monitoring artefacts.
API Design
5/10
How well APIs are designed
API surface is well-structured and ntfy-compatible with clear handlers and error returns, but lacks advanced API-versioning, idempotency key patterns, or an explicit backwards-compatibility strategy.
Evidence
iamwehi/upf/src/writer.rs: publish (POST/PUT /{topic}) - validation, size checks and ntfy JSON response iamwehi/upf/src/pusher/ws.rs: ws/json/sse handlers and SubParams parsing (since/poll handling, prepare/open)
Data Layer & Database
8/10
Working with databases
Strong, deliberate use of FoundationDB as the single coordination substrate with careful transaction boundaries, versionstamped keys, range paging and TTL/expiry handling.
Evidence
iamwehi/upf/src/store.rs: publish, drain_range_inner, arm_bell, expire, drain_after - explicit FDB transactions and paging iamwehi/upf/src/keyspace.rs: queue_key_versionstamp / ttl_key_parts and key layout helpers (key structure & versionstamp decoding)
Scalability & Performance
7/10
Handling load and speed
Clear scalability and performance thinking - sharded watches, safety poll, load generator and per-topic publish rate shaping - though formal rate-limiting, caching/invalidations or measured tuning artifacts are not present.
Evidence
iamwehi/upf/examples/loadgen.rs: engineered high-concurrency load generator + correctness checks and throttling iamwehi/upf/src/pusher/mod.rs: shard_watcher, safety_poll loop and spawn_keepalive - watch budget and fanout model
System Architecture
7/10
Overall system structure
Deliberate system architecture that treats the database as the single source-of-truth and decomposes roles (writer, pusher, janitor) with clear boundaries and background tasks.
Evidence
iamwehi/upf/src/pusher/mod.rs: Pusher::start spawns shard watchers, heartbeat and safety poll (role decomposition) iamwehi/upf/src/store.rs: all storage/coordination encapsulated behind Store with explicit transaction use and APIs
Security & Auth
4/10
Protecting data and access
Thoughtful input validation and message-size limits are present and topic names are validated, but there is little evidence of authentication/authorization, secret management, or detailed token lifecycle handling in public code.
Evidence
iamwehi/upf/src/writer.rs: topic validation, payload size checks and encode_body handling (UTF-8 vs base64) iamwehi/upf/src/pusher/ws.rs: SubCtx::prepare validates role availability and topic input, returning proper HTTP error responses
Reliability & Observability
6/10
Stability and monitoring
Good reliability and observability patterns - structured tracing calls, retries with simple backoff, safety poll fallback and cleanup guards - but advanced patterns (circuit breakers, configurable backoff strategies, SLI/SLO artifacts) are not present in public code.
Evidence
iamwehi/upf/src/pusher/mod.rs: shard_watcher handles re-arm failures with a logged retry and sleep; SubGuard drop releases affinity asynchronously iamwehi/upf/tests/e2e.rs: end-to-end tests validating correctness/behaviour (subscribe/publish flows)
Expertise
Messaging & Real-time• Senior
Go Development• Middle
Databases & Vector Storage• Senior
Technologies
Databases
Python
Go• Senior • 3y+
Rust• Senior
SQL
PostgreSQL
Rest API
gRPC
WebSockets
Tokio
Axum
Reqwest
Git
Docker
Apache Kafka
FoundationDB• mentioned only
Recommendations
  • Design and implement sharded, real-time messaging or push systems that use a database-as-coordination-layer (writer/pusher/janitor roles and FDB-style transactions).
  • Build high-throughput load-test and correctness tooling for messaging platforms (authors of the loadgen example).
  • Develop real-time delivery components and integration layers for mobile/IoT push where careful ordering, TTL and shard budgeting matter.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
upf miniflux-jobs
Senior Game Developer Confidence: Medium Generalist
A systems-focused Rust developer at a senior level who designs and implements non-trivial, domain-specific tooling and runtime components. The strongest proven skill is building performant, correctness-sensitive systems around finite-field arithmetic and a custom bytecode VM, evidenced by _cwc-src/src/field.rs and _cwc-src/src/vm2.rs. There is no evidence of game-specific work (rendering, gameplay systems, physics engines) or platform-specific console/XR gamedev in the public code.
Gameplay Systems & Mechanics
How game logic works
Not evidenced in public code
Graphics & Rendering
Drawing game visuals
Not evidenced in public code
Physics & Math
6/10
Game physics and math
Strong applied mathematics and finite-field work (bigint/field element ops) used to implement a VM and witness calculus.
Evidence
iamwehi/witness-generation-benchmarks/_cwc-src/src/field.rs: field element parsing, arithmetic and tests (many functions implementing ff ops) iamwehi/witness-generation-benchmarks/_cwc-src/src/vm2.rs: numeric/field-based VM ops and conversions (I64WrapFf, OpPow, OpShr, etc.)
Engine Proficiency
5/10
Skill with the game engine
Demonstrated non-trivial multi-crate Rust workspace usage, build scripts, wasm target and CLI tooling - evidence of engine/tooling familiarity beyond defaults.
Evidence
iamwehi/witness-generation-benchmarks/Cargo.toml: workspace with cpp feature and build profile tweaks iamwehi/witness-generation-benchmarks/cwc-wasm/Cargo.toml: cdylib target and wasm-oriented build constraints iamwehi/witness-generation-benchmarks/_cwc-src/build.rs: platform/linker environment setup
Performance & Frame Budget
6/10
Keeping the game smooth
Measured-performance oriented design: custom VM, optional parallel component execution, mmap-backed node storage and benchmark harness present.
Evidence
iamwehi/witness-generation-benchmarks/_cwc-src/src/vm2.rs: feature-gated parallel_components with spawn_component_execution and careful memory resizing iamwehi/witness-generation-benchmarks/_cwc-src/src/graph.rs + build_graph in extensions/build-circuit/src/main.rs: use of MMapNodes and explicit optimize() pass iamwehi/witness-generation-benchmarks/benches/witness.rs: criterion benchmark harness
Content Pipeline & Tooling
5/10
Tools for game content
Custom build and serialization tooling for witness graphs, CLI, and graph output - reasonable content/pipeline automation for the project's domain.
Evidence
iamwehi/witness-generation-benchmarks/_cwc-src/extensions/build-circuit/src/main.rs: parse_args(), build_graph() iamwehi/witness-generation-benchmarks/_cwc-src/src/storage.rs: serialize_witnesscalc_graph and serialization tests
Verified artifacts
boxdot/gurk-rs• ★ 1.3K kaowallet/kao• ★ 17 llbartekll/clear-signing• ★ 4 kaowallet/server• contrib
Technologies
JavaScript
C
C++
Lua
Serde
Tracing
Anyhow
Recommendations
  • Develop performance-sensitive backend or toolchain components in Rust (custom runtimes, VMs, serialization pipelines).
  • Work on cryptographic / zero-knowledge tooling, compiler frontends or witness-generation pipelines where finite-field math and deterministic execution are critical.
  • Implement high-performance, multi-threaded compute paths (profiling, mmap-backed data structures, zero-copy serialization).
  • Build CLI tools and wasm-native modules that require careful cross-target build configuration and static linking.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
witness-generation-benchmarks upf
Senior Embedded Engineer Confidence: Medium Generalist
A systems-focused Rust engineer operating at a senior (lower) level who builds non-trivial language/compiler/runtime tooling. The strongest proven skill is low-level VM/compiler and witness-graph tooling implemented in Rust (concrete artifacts: _cwc-src/src/vm2.rs and _cwc-src/extensions/build-circuit/src/main.rs). There is little or no evidence of embedded MCU firmware, hardware drivers, on-device field testing, or HDL/FPGA work in the public HUMAN-AUTHORED code.
Embedded & Firmware
Low-level device code
Not evidenced in public code
Hardware-Software Interface
Connecting code to hardware
Not evidenced in public code
Resource Constraints
3/10
Working with limited resources
Evidence of conscious resource and memory management for a high-performance native/WASM library: manual memory regions, explicit resizing to avoid stale values, and release/build profile tuning.
Evidence
iamwehi/witness-generation-benchmarks/_cwc-src/src/vm2.rs: explicit vm.memory_ff resizing and memory shrink logic in FfMReturn (avoids stale values) iamwehi/witness-generation-benchmarks/_cwc-src/extensions/build-circuit/src/main.rs: use of MMapNodes and careful node/memory setup (build_graph -> MMapNodes::new) iamwehi/witness-generation-benchmarks/Cargo.toml: [profile.release] opt-level=3, lto=true, codegen-units=1 (release tuning)
Real-time & Timing
2/10
Precise timing control
Some concurrency and synchronization design for parallel execution of components (optional feature-gated), but no hard real-time scheduling, WCET analysis, or timer/latency measurements.
Evidence
iamwehi/witness-generation-benchmarks/_cwc-src/src/vm2.rs: spawn_component_execution uses std::thread::scope, Condvar and Mutex for worker start synchronization iamwehi/witness-generation-benchmarks/_cwc-src/src/vm2.rs: feature-guarded parallel_components path and fallbacks to sequential execution
HDL & Circuit Logic
Designing digital circuits
Not evidenced in public code
Reliability & On-device Testing
3/10
Testing on real hardware
Reasonable reliability practices for a systems library: explicit error enums, checks for out-of-bounds and overflow, and unit tests; no on-device HIL/OTA or measured power/field-test artifacts found.
Evidence
iamwehi/witness-generation-benchmarks/_cwc-src/src/vm2.rs: RuntimeError enum with many checked failure modes and unit test module (test_ok) iamwehi/witness-generation-benchmarks/_cwc-src/extensions/build-circuit/src/main.rs: unit test test_bigint_to_usize in tests module iamwehi/witness-generation-benchmarks/_cwc-src/src/parser/mod.rs: multiple parse_*/test_* functions (parser unit tests)
Expertise
Low-level Development & Tooling• Senior
Industries
Blockchain & Crypto• Middle
Recommendations
  • Lead development of Rust-based compiler toolchains, VM runtimes and graph/IR tooling (implement features, optimize memory layout, extend bytecode).
  • Build and optimize WASM/native bridging components and performance-sensitive libraries (witness calc, crypto backends, memory-mapped node storage).
  • Design and implement testable graph/IR transformations and deterministic parallel execution paths for computation graphs.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
witness-generation-benchmarks upf