Senior Systems & Cloud Engineer (Rust • Linux • DevOps)

Location:

Engagement:

• Programming:

• Rust

  (ownership, lifetimes, async with tokio/async-std, traits, error handling).
• Solid

  Python

  and/or

  Go

  for tooling/automation.
• Comfortable with

  C/C++

  interop (FFI) when needed.

• Linux on ARM & x86_64:

• Debian/Raspberry Pi OS administration, systemd

  units/targets, logging (journald).
• Kernel/modules basics,

  udev

  ,

  DBus

  , device permissions, GPIO/serial/USB.
• Filesystems, partitions, bootloaders, cross-compiling for

  aarch64/armv7

  .

• Networking & security:

• TCP/IP, DNS, DHCP, mDNS/Avahi, firewalling (iptables/nftables

  ), routing/VPN (

  WireGuard

  ).
• TLS/X.509, mTLS, certificate lifecycle (ACME), OAuth2/OIDC, SSH hardening.
• Linux security:

  seccomp

  ,

  capabilities

  ,

  AppArmor/SELinux

  (practical use), sandboxing.

• Containers & environments:

• Docker/Podman

  , Compose, image layering, multi-arch builds (buildx/QEMU).

• Devcontainers

  ,

  VS Code Server/GitHub Codespaces

  ; reproducible local vs cloud environments.
• Image signing/SBOMs (cosign, Syft/Grype) and vulnerability scanning (Trivy).

• CI/CD & Git:

• Git

  proficiency: clean history, rebasing, branching models, code review discipline.

• GitHub Actions

  (or GitLab CI): matrices, caches (pip/pnpm/sccache/ccache), artifact mgmt.
• Promotion flows (dev→stage→prod), release/versioning, conventional commits.

• Cloud fundamentals:

• AWS/GCP/Azure basics: compute, object storage, networking, load balancers.

• IAM least-privilege, OIDC federation from CI (no static keys), secrets management.
• Registries (ECR/GAR/ACR), private networking, cost/quotas monitoring.

• Observability & reliability:

• Metrics/logs/traces: Prometheus/Grafana/Loki (or ELK), alerting SLO/SLI thinking.

• Health checks, graceful shutdown, backoff/retries, circuit breakers.

• Rust in production (services/daemons/CLIs),

  tokio

  ,

  reqwest

  ,

  serde

  ,

  tracing

  ,

  anyhow/thiserror

  .
• Packaging & distribution:

  .deb

  creation, systemd service files, A/B or

  OSTree/RAUC

  style updates.
• Property-based testing (

  proptest

  ), fuzzing (

  cargo-fuzz

  , libFuzzer/AFL), static analysis (clippy, rust-analyzer).
• Cross-compilation toolchains (cross, zig-cc, CMake/Ninja) and multi-arch CI.

• Audio/IO on Linux (ALSA/Pulse), BLE/Wi-Fi provisioning flows, NFC/serial bridges.
• IaC:

  Terraform/Ansible

  ; reverse proxies (Nginx/Caddy/Traefik).
• Data layer familiarity: PostgreSQL, Redis, MQTT; containerized DBs for tests.
• SSO (SAML/OIDC) integrations; enterprise network patterns (bastions, proxies).

• Writes clear design docs and RFCs before changes.
• Automates toil; prefers reproducible envs over snowflake servers.
• Secures by default: zero-trust mindset, secrets never in code, least privilege.
• Measures everything: adds metrics/logs/tests as part of each change.
• Communicates crisply in PRs; keeps branches small and reviewable.

• Share a repo or gist demonstrating

  Rust

  (async + tests + logging).
• Brief note on your

  Linux

  hardening approach (services, users, sandboxing).
• Example CI (YAML) you’ve authored with caching, multi-arch build, and artifacts.

• Apply with:

  Resume, GitHub/GitLab links, a short note on relevant Rust/Linux/Cloud work, and your availability/rate.