NICE-DEV

Backend Engineering · Software Architecture · DevOps

Building reliable APIs, backend systems, and developer tools — with a growing focus on Rust, distributed systems, and cloud infrastructure.

Portfolio · GitHub

I'm Azaël Sawadogo, a software developer focused on backend engineering. I enjoy understanding how systems behave under real constraints: concurrency, failure, security, performance, and maintainability.

• Primary focus: backend development, API design, and software architecture
• Systems interests: Go, Rust, networking, and distributed systems
• Infrastructure: Docker, CI/CD, observability, and cloud-native tooling
• Engineering approach: explicit trade-offs, useful tests, and practical designs over unnecessary complexity

I'm interested in building software that is useful to other developers and contributing to open-source projects.

Languages

Backend & data

DevOps & systems

_{These badges represent my working stack and areas of focus, not equal proficiency in every technology. My orientation is backend-first.}

Go · HTTP proxy · WebAssembly · Systems engineering

An experimental programmable HTTP data plane. A small Go proxy routes requests through capability-scoped WebAssembly extensions, with explicit limits, lifecycle controls, health endpoints, and Prometheus-compatible metrics.

Fastify · PostgreSQL · Redis · Go · Docker

A media-provider API and CLI ecosystem. The API uses authentication, rate limiting, caching, interchangeable providers, and automatic failover; the Go CLI is maintained as a separate component.

Python · Go · Decision theory · Computer vision

An adaptive perception controller that chooses when and how much computation to spend on an input. It explores cost-aware decisions on top of existing vision models rather than building another vision model.

Policy language · AI agent security · Information flow

An early-stage project exploring explicit information-flow policies and audit records for LLM agent pipelines. The repository documents its scope, threat model, and current implementation status.

• Architecture: clear boundaries, explicit responsibilities, and designs that can evolve.
• Reliability: account for concurrency, retries, duplicate events, and partial failures.
• Security: validate input, protect authentication boundaries, and keep permissions explicit.
• Operations: make systems observable, testable, and deployable through repeatable workflows.
• Simplicity: solve the actual problem before introducing extra infrastructure.

• Rust for systems programming and reliable services
• Go for networking, infrastructure, and developer tooling
• Software architecture and distributed-systems trade-offs
• DevOps fundamentals: containers, CI/CD, deployment, and observability
• Testing race conditions, idempotency, and failure handling