Career Change · Rust Engineer

Sekou Diarra

Java/Go backend · 13 yrs · TF1, Canal+, GEODIS, Societe Generale

“A real platform was the goal, not a tutorial. We shipped role-scoped access and AI that respects tenant data.”

Sekou came into the engagement a 13-year freelance Java and Go engineer, with missions at TF1, Canal+, GEODIS, Societe Generale, and SNCF behind him. Rather than toy exercises, we scoped a real product from day one: a property management platform for individual landlords, built on Dioxus fullstack, Axum, and SQLx, with two distinct roles (owner and tenant) enforced end to end. The goal was a production codebase he could defend in a system design interview, not a tutorial repo.

Over roughly four months and 83 commits, the project grew from a hardcoded auth template into full CRUD across properties, tenants, leases, and payments, then closed with a context-first AI assistant scoped by role. The habits from 13 years of freelance backend work showed up directly in the build: a security pass mid-project caught real bugs before they ever reached a user.

13 yrs

Java and Go, high-reliability distributed systems

Freelance

Missions at TF1, Canal+, GEODIS, Societe Generale

MTTR < 1h

Observability work shipped at TF1 and GEODIS

Commits in the Rust project

LinkedIn rebranding

The challenge

Role-scoped access, enforced everywhere it matters

Two roles, owner and tenant, each needed a hard data boundary: an owner sees every property they manage, a tenant sees only their own lease. Getting that right in Rust meant deciding, query by query, whether scoping came from an explicit role check or was safe by construction because the id could only ever be the caller's own.

That same discipline carried into the AI assistant: authenticated role chooses the context path, and the scoping id is injected server-side, never supplied by the model, so a manipulated prompt still can't read across tenants.

•User-enumeration leak in login, closed before launch
•Panic-on-None in the auth path, now a recoverable Err
•Prepared context for the AI assistant, no raw SQL exposed

The outcome

A shipped platform, not a tutorial

By the end of the engagement Sekou had a working property management platform: full CRUD for properties, tenants, leases, and payments, two role-scoped portals, and a context-first AI assistant answering owner and tenant questions against their own data only.

He's now taking that project, and 13 years of production engineering habits proven in Rust, into interviews for senior Rust engineering roles.

✓Full owner and tenant portals with role-based route guards
✓Context-first AI assistant, read-only and role-scoped
✓A codebase he can defend line by line in interviews

Foundations

13 years of Java and Go, redirected into Rust

Sekou had spent over a decade shipping distributed backend systems for TF1, Canal+, GEODIS, and Societe Generale as a freelance Java and Go engineer. The instincts around microservices, observability, and production reliability transferred straight over. What didn't transfer for free was Rust's ownership model, so we scoped a real product from day one instead of toy exercises: a property management platform for individual landlords, role-scoped between owners and tenants.

✓Dioxus 0.7 fullstack: server functions, session auth, role-based layouts
✓Domain-based structure: one data/service/routing module per entity
✓Owner vs tenant access scoping decided before the first CRUD route

Access boundary

Role decides the data path

auth · secured_server · services

Session

user + role

Access gate

owner or tenant

Scoped data

existing queries

Owner context

properties · dashboard
open maintenance · late payments

Tenant context

own lease · own payments
own maintenance requests

scope from sessionno raw SQLsame service layer

Deep dive

The bug a senior engineer's habits caught

Mid-build we did a real security pass on the auth path, the kind of review Sekou runs on his own freelance work by habit. It caught a user-enumeration leak: login returned a distinct error for “user does not exist” versus “password does not match,” which lets an attacker map valid emails one login attempt at a time. The same pass found a pool.expect() panic running on every request instead of only at boot, meaning one transient connection hiccup could have killed the whole server.

✓Login now returns one generic error regardless of which check failed
✓get_from_email() no longer swallows real DB errors as "not found"
✓auth_context::load_user returns Err instead of panicking on a None pool

Security pass

The auth path fails safely

auth · access_controller

credentials

Generic error

no enumeration

Session

authenticated user

Role guard

route permission

Two bugs removed

User enumeration

One login error for both failure cases.

Panic on None

Recoverable Err instead of request-time crash.

Capstone

A context-first AI assistant, not a RAG bolt-on

The closing feature was an in-app AI assistant for owners and tenants to ask about their own data. The design decision that mattered: existing role-scoped queries gathered before the model call, not vector search. The model never sees raw SQL and never picks its own scope, the owner_id or tenant_id is injected server-side from the session before context is assembled, so a compromised prompt still can't leak another tenant's data.

✓Owner and tenant context use different existing scoped service functions
✓The model receives prepared JSON, never raw SQL or a caller-chosen scope
✓Read-only context, rate-limited requests, and chat events logged

Context-first AI

Useful answers without widening access

chat · agent_loop

Question

owner or tenant

Scoped context

fetched first

LLM answer

Claude or OpenAI

Model sees prepared JSON, never the database

owner: 4 scoped fetchestenant: 3 scoped fetchesrate limitedchat_events logged

The journey

One clear path through the build

Step 011 / 5

Week 1

Dioxus fullstack auth exercise: sessions, roles, and server functions.

Step 022 / 5

Weeks 2-4

Domain-based CRUD scaffold: properties, tenants, leases, payments, per-role.

Step 033 / 5

Mid-build

Security pass: closed a user-enumeration leak and a panic-on-None in the auth path.

Step 044 / 5

Weeks 5-8

Owner and tenant portals, RBAC route guards, N+1 query fixes.

Step 055 / 5

Launch

Context-first AI assistant shipped: role-scoped, read-only, no raw SQL exposed to the model.

Drag to explore · Select a milestone to read the full story

Mentor perspective

Sekou Diarra brought 13 years of Java and Go backend experience, so the challenge was not learning what production engineering means. It was translating those habits into Rust ownership, explicit domain boundaries, and a real product. He applied the review discipline throughout the build, moving from auth exercises to a property platform with RBAC and role-scoped AI.

Max Wells

Rustify mentor