Vancouver, BC · iOS and identity engineer · Founder, Hanzo Technologies

Quielo Rodriguez

Open to Work Open to engineering roles, iOS and identity first.

iOS and identity engineer. Founder, Hanzo Technologies. Current work: a health journal on the App Store, and a credential system in prototype.

Work

Summaries are computed on-device. They have no business on a server.

Live on the App Storesince April 2026

Hanzo Health

A wellness journal for iPhone, iPad and Apple Watch, for people with chronic conditions like PCOS and endometriosis.

350users

Model
Freemium
Health data
HealthKit
On the device
Summaries
For appointments
Doctor reports
Localization
Japanese
Prototype, synthetic data only

Hanzo Digital Credential Infrastructure

Work-authorization credentials held on the person's own device. Issued over OpenID4VCI, presented over OpenID4VP, encoded as ISO mdoc, anchored in X.509 PKI.

  • Local issuer
  • Issuance and lifecycle orchestration
  • Holder demo
  • Verifier with a trust registry

660synthetic tests, plus senior and security review

A synthetic MVP and pilot foundation.

Examples

Swift, on the device

Illustrative · fixed sample value Read the file on GitHub

Heart rate card

examples/SampleHeartRateCard.swiftSwift, 19 lines
import HealthKitimport SwiftUI// Fixed sample value; no HealthKit query or device read.struct SampleHeartRateCard: View {    private let sample = HKQuantity(        unit: HKUnit.count().unitDivided(by: HKUnit.minute()),        doubleValue: 72    )    var body: some View {        VStack(alignment: .leading) {            Text("Synthetic heart rate")            Text("\(Int(sample.doubleValue(for: HKUnit.count().unitDivided(by: HKUnit.minute())))) BPM")                .font(.title2)        }        .accessibilityElement(children: .combine)    }}

Rendered output

Synthetic heart rate

72 BPM

VoiceOver: "Synthetic heart rate, 72 BPM"

What it proves

Typed HealthKit units instead of loose doubles, and a SwiftUI view VoiceOver reads as one element instead of two fragments.

What it does not do

No query, no permission prompt, no device read.

Illustrative · sample values only

Weekly snapshot

Inspired by the shared snapshot model Hanzo Health uses across the app, the Watch app and the widgets.

Rewritten for this pageSwift, 15 lines
// Illustrative only. No HealthKit query, no network, no device read.struct DaySnapshot {    let date: Date    let restingHeartRate: Double?    let steps: Int    let sleepHours: Double}func weeklySnapshot(days: [DaySnapshot]) -> (averageRestingRate: Double?, totalSteps: Int, averageSleep: Double) {    let rates = days.compactMap(\.restingHeartRate)    let averageRate = rates.isEmpty ? nil : rates.reduce(0, +) / Double(rates.count)    let totalSteps = days.reduce(0) { $0 + $1.steps }    let averageSleep = days.isEmpty ? 0 : days.reduce(0) { $0 + $1.sleepHours } / Double(days.count)    return (averageRate, totalSteps, averageSleep)}

TypeScript, on the identity side

Illustrative · mock signature result

Credential precheck

What it proves

The four gates a verifier passes before trusting anything: signature, trusted issuer, an expiry that actually parses, then the clock. The clock is injectable, so the check is testable.

What it does not do

No cryptography. The issuer sits on .invalid, a domain reserved so it never resolves.

Read the file on GitHub
examples/demo-credential-precheck.tsTypeScript, 26 lines
// The signature flag below stands in for a cryptographic check.type DemoCredential = {  issuer: string;  expiresAt: string;  signatureVerifiedByMock: boolean;};function passesDemoPrecheck(  credential: DemoCredential,  trustedIssuers: ReadonlySet<string>,  now: Date = new Date(),): boolean {  const expiry = Date.parse(credential.expiresAt);  return credential.signatureVerifiedByMock    && trustedIssuers.has(credential.issuer)    && Number.isFinite(expiry)    && expiry > now.getTime();}const sample: DemoCredential = {  issuer: "issuer.example.invalid",  expiresAt: "2099-01-01T00:00:00Z",  signatureVerifiedByMock: true,};console.log(passesDemoPrecheck(sample, new Set(["issuer.example.invalid"])));
Console outputtrue
Illustrative · every check is a stand-in

Verifier gates

Inspired by the verifier service in the credential work, which enforces its checks in a fixed order.

  1. Gate 1

    Purpose

    "purpose not allowed"

  2. Gate 2

    Nonce

    "nonce already used"

  3. Gate 3

    Issuer

    "issuer not trusted"

  4. Gate 4

    Revocation

    "credential revoked"

  5. Gate 5

    Disclosure

    "requested field not disclosable"

Rewritten for this pageTypeScript, 31 lines
// Illustrative only. Every check below is a stand-in: no cryptography,// no real issuer, no real credential format.type DemoCheck = (request: DemoRequest) => string | null;interface DemoRequest {  purpose: string;  allowedPurposes: ReadonlySet<string>;  nonceSeen: boolean;  issuerTrusted: boolean;  credentialRevoked: boolean;  requestedFields: string[];  disclosableFields: ReadonlySet<string>;}const checks: DemoCheck[] = [  (r) => r.allowedPurposes.has(r.purpose) ? null : "purpose not allowed",  (r) => r.nonceSeen ? "nonce already used" : null,  (r) => r.issuerTrusted ? null : "issuer not trusted",  (r) => r.credentialRevoked ? "credential revoked" : null,  (r) => r.requestedFields.every((f) => r.disclosableFields.has(f))    ? null    : "requested field not disclosable",];function verifyDemo(request: DemoRequest): string | null {  for (const check of checks) {    const failure = check(request);    if (failure !== null) return failure;  }  return null;}

What it proves

Fail-fast ordered verification, purpose binding, replay protection via a single-use nonce, revocation handling, and minimal disclosure.

What it does not do

No cryptography, no real issuer, no real credential format.

Illustrative · not the real lifecycle engine

Lifecycle transitions

Inspired by the issuance and lifecycle orchestration in the credential work.

Allowed transitions, from row to column
from \ toissuedsuspendedrevokedexpired
issuednoyesyesyes
suspendedyesnoyesyes
revokednononono
expirednononono

What it proves

Domain modeling with fail-closed terminal states: revoked and expired transition nowhere.

What it does not do

No persistence, no real events.

Rewritten for this pageTypeScript, 13 lines
// Illustrative only. A tiny state machine shape, not the real lifecycle engine.type DemoLifecycle = "issued" | "suspended" | "revoked" | "expired";const allowedTransitions: Record<DemoLifecycle, DemoLifecycle[]> = {  issued: ["suspended", "revoked", "expired"],  suspended: ["issued", "revoked", "expired"],  revoked: [],  expired: [],};function canTransition(from: DemoLifecycle, to: DemoLifecycle): boolean {  return allowedTransitions[from].includes(to);}

Activity

2,007 contributions in the last year.

Skills

Apple platforms
Swift, SwiftUI, HealthKit, Xcode, watchOS, widgets, complications
Identity standards
OpenID4VCI, OpenID4VP, ISO mdoc, X.509
Server, web, and tooling
Node.js, TypeScript, JavaScript, HTML, Git

Side projects

Surf-Tracker (Swift), Regimen (Swift), Calyra, plus a fitness app and a rabbit tracker from earlier experiments. Some archived.

Contact

Open to engineering roles, iOS and identity first. Based in Vancouver. Fastest contact: GitHub. Most of my work is private; walkthroughs available under NDA.

Now: shipping the next Hanzo Health update; looking for an engineering role in Vancouver.