We Engineer Software Worth Trusting
FiduciaWay is a technology company of 140 engineers, designers and SREs. We design the product, architect the system, and run a code-update workflow where every change is reviewed by a human, verified by a machine, signed with provenance and watched in production — before your users ever meet it.
Trusted by teams whose software cannot afford to fail
Full-Cycle Software Engineering
Six crafts, one standard: every system we ship is designed, architected, built, tested and operated by the same accountable hands.
Product Design & Experience
Research-driven UX, living design systems and WCAG 2.2 AA accessibility baked into every screen — interfaces designed for the worst day, not just the demo.
Software Architecture
Domain-driven, evolvable systems with every significant decision captured as an Architecture Decision Record — context, choice and consequences you can read.
Platform & Backend Engineering
Distributed backends and integration layers built for correctness first: idempotent handlers, exactly-once effects, and failure modes designed before the happy path.
Cloud & Reliability Engineering
Kubernetes estates, infrastructure as code and a real SRE practice — SLOs, error budgets and 24/7 coverage that make uptime contractual instead of aspirational.
Quality & Test Engineering
A real test pyramid — thousands of fast unit tests, contract and integration suites, and production canaries that catch what mocks cannot.
Applied AI & Data Engineering
Machine learning and analytics shipped under the same rules as everything else: versioned, reviewed, monitored and explainable — models are code, and code has gates.
The Technology Company Behind Software That Has to Work
Founded in Cairo in 2021 by software and security engineers, FiduciaWay has grown into a 140-person technology company with offices in Cairo, Dubai and Berlin. We design, architect, build and operate the platforms that manufacturers, marketplaces and enterprises bet their reputations on — and we run the same disciplined engineering process on every line of code we ship.
Mission
Make trustworthy software the default — engineered, tested and operated in the open.
Values
Trust First
We design for the worst day, not the demo. Every decision survives the question: “what does this do to trust?”
Proof Over Promises
Claims ship with evidence — test runs, audit trails, postmortems and delivery metrics. If we cannot measure it, we do not claim it.
Craft in Engineering
Boring technology, exciting reliability. We pick tools for their failure modes, not their keynote demos.
Ownership & Care
The engineer who builds it carries the pager for it. Accountability is a person, not a department.
Timeline
- 2021
Founded in Cairo
Three engineers, one 40-page engineering review, and a first client who trusted the document more than the demo.
- 2022
Vault 1.0 — first platform client
Nile Logistics Group moves 11M freight documents onto Vault. Zero incidents in year one.
- 2023
SOC 2 Type II + Dubai office
Independent audit passes with zero exceptions. DIFC office opens to cover Gulf clients.
- 2024
ISO 27001 + 30 deploys a day
The engineering org reaches on-demand deployment across all platforms — small batches, gated merges, canary releases.
- 2025
26 countries, Berlin lab
Sentinel watches 4.8B events. Berlin lab opens for platform research and EU compliance engineering.
- 2026
Bridge goes live
The enterprise integration platform goes live with four founding clients — its release pipeline public from day one.
From Idea to Production, One Disciplined Loop
Every feature at FiduciaWay travels the same engineered path — designed with users, reviewed by engineers, verified by machines, released gradually to production. No shortcuts, no heroes: the process itself is part of the product.
Design & Architect
Every change starts on paper: user research, a written RFC, and an architecture review for anything that touches a boundary. We design for the worst day, not the demo.
Implement & Review
Trunk-based development with small pull requests — sized to what research says reviews do best: under 400 lines, reviewed by a human within hours, never merged unreviewed.
Verify & Gate
The pipeline is the gatekeeper: unit, contract and integration tests, static typing, dependency and secret scanning, SBOM and signed provenance. Nothing red ever merges.
Release & Operate
Canary rollouts (1% → 10% → 100%), SLO watch, automatic rollback, and blameless postmortems when we get it wrong. The engineer who builds it carries the pager for it.
Every Change Travels the Same Provable Path
From an engineer’s keyboard to production in under an hour — gated at every step by machines, judged at every merge by humans. This is the workflow that makes our software trustworthy, and it is the same for a one-line fix or a new platform.
Commit
Signed commits, pre-push hooks, secrets blocked at the door.
Pull Request
Small by design — under 400 lines, because that is where review works best.
Human Review
Every merge reviewed by an engineer who can explain the change out loud.
CI Gates
Build, unit and contract tests, static analysis, dependency and secret scans.
Signed Artifact
SBOM and SLSA provenance — the build proves where it came from.
Staging
Smoke and end-to-end suites against production-shaped data.
Canary
1% → 10% → 100% of traffic, with SLOs watched at every hop.
Verify & Rollback
Post-deploy checks; anything off rolls back in seconds, automatically.
We Don’t Ask You to Trust Us. We Show You.
Our engineering practice is mapped to public, auditable frameworks — so any user, auditor or regulator can check our work instead of taking our word for it.
NIST SSDF
Secure development mapped to the NIST framework — peer review, secure design and vulnerability handling are named, numbered practices here, not vibes.
OWASP ASVS
Our security requirements are verified against the OWASP Application Security Verification Standard, level 2, every release.
SLSA
Signed build provenance for release artifacts — you can verify where every binary came from, down to the commit.
DORA Four Keys
Deployment frequency, lead time, change failure rate and recovery time — tracked, published and reviewed like financials.
ISO 27001
An information security management system that is audited annually — by auditors we do not choose.
SOC 2 Type II
Controls over security, availability and confidentiality — examined over time, not just photographed once.
WCAG 2.2 AA
Accessibility is a release gate, not a retrofit — bilingual, RTL-first, screen-reader tested.
CIS Benchmarks
Infrastructure hardened against CIS baselines — drift from the baseline fails the pipeline.
Four Systems. One Engineering Standard.
Each platform is a production system with a public uptime record, a named owner, an architecture you can read — and the same gated code-update workflow behind every release.
Records & Approvals
Vault
Envelope-encrypted records management and multi-party approvals with a policy engine that enforces your rules — not your hopes.
Explore VaultImmutable Audit
Ledger
An append-only event ledger that turns every business event into a signed receipt your auditors can verify independently.
Explore LedgerMonitoring & Detection
Sentinel
Real-time anomaly radar: behavioral baselines, explainable scoring and a rule studio your operations team actually controls.
Explore SentinelIntegration Platform
Bridge
Idempotent, reconciliation-aware sync across ERPs, CRMs and partner APIs — every batch replayable, every discrepancy paged.
Explore BridgeProduction deploys every day, across all platforms
Uptime honored since 2023 — a 52-minute yearly error budget, spent in public
Defects caught by review and CI before code ever reaches production
Median time to recover from any production incident
Six crafts, one engineering standard
Frontend, Backend, Mobile, DevOps, QA and Data Science — the people behind every line of code that touches production. Each team owns its craft end-to-end; all six share the same contracts: one audit log, one CI pipeline, one critical-path matrix, one SLO envelope, one on-call rotation.
A FiduciaWay team is not a department; it is a discipline that owns a craft end-to-end. The Frontend team owns the trust surface where the thumb meets the ledger. The Backend team owns the event ledgers and APIs that never lose a record or an explanation. Mobile owns the apps people open at 2am to approve something they cannot undo. DevOps owns the rails every release rides on. QA owns the contract that lets engineering ship fast without shipping fear. Data Science owns the audit log read forward, into decisions an auditor can interrogate.
What unifies them is not an org chart; it is a set of shared engineering contracts that no team can opt out of. Every release rides the same canary pipeline. Every critical flow runs the same scenario matrix. Every service carries the same SLO envelope and the same on-call runbook. Every model is explainable, every secret is rotated, every audit log is replayable. The teams disagree about how to build; they do not disagree about how to ship — because shipping is the contract that earns the trust the brand is named for.
Shared contracts
What all six teams share, by contract
These are not posters on the wall — they are the rules every team enforces in CI and in review.
One audit log
Append-only, cryptographically chained, replayable from genesis to today. Every team writes to it; no team reads from anywhere else.
One canary pipeline
1% then 10% then 100%, with automated rollback on SLO breach. The critical-flow matrix runs against every stage before promotion.
One critical-path matrix
500+ scenarios covering the happy path, every known error path, and the unexplored paths property-based tests generated. Runs against every release candidate.
One SLO envelope
Every service carries an SLO and an error budget; the budget gates feature velocity. Spend the budget, run out, deploys freeze until reliability pays it back.
One on-call rotation
Runbooks written by the engineer who shipped the system. We do not page humans for things a job can catch; an alert without a runbook does not ship.
One trust contract
Every model is explainable, every secret is rotated, every migration is reversible, every release is revertible. Trust is engineered, not promised.
How the teams interface
The seams are the system
A platform is only as trustworthy as its weakest seam. Here is how the six teams meet at the boundaries that matter.
OpenAPI contracts co-signed; the spec ships before the code. A breaking change the frontend cannot absorb does not merge.
Backend owns the SLO; DevOps owns the canary and the rollback lever. Neither ships a critical path without the other's sign-off.
The critical-path matrix runs against every release candidate, on four browsers, two languages, two themes, on five-year-old hardware. Red blocks ship.
Features from the audit log, models explainable by construction, predictions auditable. A regulator's "why" is a query we already have.
A shared TypeScript core co-owned by both teams; contract tests prove both ends agree on every PR. Offline-first flows queue locally, sync when the network returns.
Proof, in Their Words
FiduciaWay didn’t sell us software — they handed us proof. Every claim arrived with a report, every release with an audit trail. Our auditors asked who built it.
Tarek El-Sayed
CTO, Nile Logistics Group
Stories from the Engine Room
Engineering culture, incident honesty, and the craft of software people can trust — written by the people on call.
Engineering Software You Can Trust — A Grand Guide in 10 Chapters
Product design, architecture, the development cycle, code review, testing, deployment, security and operations. Written by our principal engineers for anyone who ships software — zero fluff, field notes from production.
Start ReadingLet’s Build Something Trustworthy
Tell us what you are building and what keeps you up at night. A principal engineer — not a chatbot — replies within one business day.
Offices
Cairo
Headquarters & Engineering Hub
Dubai
DIFC — Client Coverage & SRE
Berlin
EU Research & Platform Engineering
After you write
What happens to your message
No ticket queue, no triage bot, no "we'll be in touch". Here is the path your message takes from send to a real conversation with an engineer who can answer your question.
Acknowledged by a human
You get a reply from a named principal engineer within one business day — not an auto-responder, not a "we'll be in touch". The reply either answers your question or asks the one clarifying question that lets us answer it.
Scoped by the right team
If your question is about data integrity, the Backend team picks it up; if it is about a mobile flow, Mobile does; if it is about an integration, the principal who replied co-scopes it with the team that owns the surface. No "we'll route this internally".
A real conversation
We offer a 30-minute call with the engineer who would actually work on your problem — not a salesperson. You can ask technical questions and get technical answers, in English or Arabic, with diagrams if needed.
A written follow-up
After the call, you get a written summary — the questions you asked, the answers we gave, the next steps if any — so nothing depends on memory or a chat log. The summary is yours to keep.
Trustworthy Software Is a Process, Not a Promise.
Talk to our engineers — not a sales deck — about your product, architecture or reliability challenge. We will walk you through our development cycle and code-update workflow, and show you the evidence, before we talk about anything else.