Accepting new engagements — Q2 2026

Android apps. Rust backends.
Software that doesn't break.

RB-Development is a one-person engineering studio building mobile apps, websites, and backend systems — with an obsession for security, correctness and maintainability.

Based in Bratislava · Remote
Focus Android · Rust · Security
Experience 10+ years shipping software
Services

Four disciplines, one engineer.

Every project is handled end-to-end — from the first conversation to deployment and long-term maintenance. No hand-offs, no diluted accountability.

Android Applications

Native Android apps built with Kotlin and Jetpack Compose. From concept and UX to Play Store release, including offline-first architectures and background sync.

  • Kotlin · Jetpack Compose
  • Room, WorkManager, DataStore
  • CI, automated testing & signing

Websites & Web Apps

Fast, accessible, no-framework-bloat websites and web applications. Built to score well on Lighthouse, work offline, and load on the weakest connection.

  • Static sites & PWAs
  • REST & GraphQL APIs
  • Accessibility (WCAG 2.2 AA)

Rust Backend Systems

High-performance, memory-safe backend services in Rust. Axum, Actix, Tokio — built for predictable latency, strict typing, and honest error handling.

  • Axum · Actix · Tokio
  • PostgreSQL · SQLx · Redis
  • Observability & tracing

Security Consulting

Code review, threat modeling, and remediation guidance. Focused on realistic attackers, real-world trade-offs, and security you can actually ship.

  • Secure code review
  • Threat modeling (STRIDE)
  • Crypto & auth architecture

Technical Due Diligence

An honest second opinion. Independent review of a codebase or architecture — what's healthy, what's risky, and what it would cost to fix.

  • Codebase audits
  • Architecture review
  • Written findings & roadmap

Long-term Maintenance

Ongoing support for apps and services already in production. Bug fixes, dependency upgrades, incident response, and feature work on a retainer.

  • Dependency & platform updates
  • Monitoring & incident response
  • Predictable monthly retainer
Approach

Engineering, not guesswork.

A small studio can move fast — but speed without rigor is just technical debt arriving early. Here's how projects actually run.

1 · Understand the real problem

Before writing code, we talk. What does success look like? Who is this really for? What's been tried? A project that starts with a clear problem statement is already half-solved.

  • Discovery call & written brief
  • Scope, constraints, non-goals
  • Realistic timeline & budget

2 · Build in the open

You get a Git repository, a staging environment, and a short weekly update from day one. No "big reveals" — you see the progress, the trade-offs, and the code as it's written.

  • Weekly demos & written updates
  • Staging environment with every change
  • Commit access & full documentation

3 · Ship, then support

Launch is the start, not the end. Every project comes with a written runbook, clear handover notes, and the option of a maintenance retainer — because the first production bug is always worse at 3am than at 3pm.

  • Release, rollback & monitoring in place
  • Runbook & architecture documentation
  • Retainer option for ongoing work

By the numbers

10+ Years shipping production software
40+ Projects delivered end-to-end
100% Code written by a human, by me
0 Critical incidents in the last 3 years
Stack

Tools chosen for the job, not the hype.

Boring technology where it belongs. Modern where it earns its keep. Everything here has been used in production — not just on a weekend.

Android

  • Kotlin, Coroutines, Flow
  • Jetpack Compose, Material 3
  • Room, DataStore, WorkManager
  • Hilt / Koin, Ktor client
  • JUnit, MockK, Espresso

Web

  • HTML, CSS, vanilla JS
  • TypeScript where it pays off
  • Astro, SvelteKit, Next.js
  • PostgreSQL, SQLite
  • Cloudflare, nginx, Caddy

Backend · Rust

  • Axum, Actix-Web, Tower
  • Tokio, async-std
  • SQLx, SeaORM, Diesel
  • Serde, Tracing, OpenTelemetry
  • Docker, systemd, Nomad

Security

  • Threat modeling (STRIDE, attack trees)
  • OWASP ASVS, MASVS
  • Cryptography review (libsodium, ring, RustCrypto)
  • OAuth 2.1, OIDC, WebAuthn
  • Static analysis, fuzzing, sandboxing
About

A one-person studio. On purpose.

RB-Development is run by a single engineer who cares about the whole stack — from the low-level byte to the pixel the user taps. No account managers, no junior hand-offs, no marketing varnish.

Most work comes from word of mouth: teams that want a dependable engineer who can own a feature, a service, or an entire product without needing to be managed. If that sounds like what you're looking for, say hello.

Get in touch
Contact

Start a conversation.

Tell me about your project — even one paragraph is enough. I respond personally, usually within one business day.

Or email directly: rb@r3v.dev