XFlow
The control plane: account entry, app directory, routing, operational visibility, assistant workflows, and cross-app status context.
Technical evidence packet
A six-product app ecosystem built to prove production-level full-stack engineering.
This page is a technical evidence packet for reviewers evaluating the architecture, implementation depth, authority boundaries, production readiness, and AI-assisted product workflows behind the XFlowx ecosystem.
Reviewer lens
What to evaluate
System boundaries
Real public surfaces
Cross-app routing
Operational proof
AI product judgment
30-second version
Plain-language map of the ecosystem.
XFlowx is a six-product ecosystem where the technical signal is the way authority, product workflows, proof scripts, and deployment evidence connect across app boundaries.
Verixet
The billing and entitlement authority: plans, checkout, usage admission, workspace billing state, and commercial governance.
Rataify
The trust and verification layer: reviewable proof surfaces, policy signals, issue evidence, and public trust posture.
AudAiX
The audit and monitoring layer: launch checks, accessibility/Lighthouse review, regression visibility, and reporting surfaces.
WordGeni and Crevux
AI product workflow examples: writing intelligence, source-grounded publishing, media generation, asset workflows, and creative review loops.
Proof layer
Proof scripts, smoke tests, public routes, deployment evidence, route guardrails, and generated reports keep claims tied to runnable evidence.
Why this matters for hiring
The evaluation signal is ownership across a product platform.
This project demonstrates full-stack product engineering, platform thinking, auth/billing/data/deployment ownership, AI product judgment, and cross-app architecture. The evidence is not one polished screen; it is the connected set of authority boundaries, product decisions, proof scripts, routes, and operational surfaces.
Full-stack product engineering across Next.js/React surfaces, API boundaries, auth flows, billing state, data models, and production route behavior.
Platform thinking through a control-plane model, app registry, shared contracts, authority boundaries, and cross-app routing.
Ownership of auth, billing, data, deployment, proof scripts, QA strategy, public routes, and guardrail documentation.
AI product judgment shown through practical workflows in WordGeni, Crevux, AudAiX, Rataify, Verixet, and XFlow rather than generic AI demos.
Cross-app architecture that separates control plane, billing authority, trust verification, monitoring, and product workflow surfaces.
Suggested reviewer path
A practical route through the evidence.
This order keeps the review grounded: start with the system map, then inspect the authority layers, AI workflow examples, and proof coverage.
- 1
Start with ecosystem overview.
- 2
Open XFlow app directory.
- 3
Review Verixet billing authority.
- 4
Review Rataify trust surfaces.
- 5
Review AudAiX audit/reporting surfaces.
- 6
Review WordGeni and Crevux AI workflows.
- 7
Review proof coverage and guardrails.
What this demonstrates
A compact review of the engineering surface area.
The point is not that every product has the same maturity. The point is that Robert Schuelke's ecosystem exposes serious full-stack design decisions across real app boundaries.
Centralized OAuth-style auth through XFlow
Verixet-controlled billing and entitlements
Shared Supabase architecture with app-separated schemas
Cross-app lander/auth/pricing routing
Public trust/security surfaces
Event ingest and operational proof flows
AI-assisted product features across writing, audits, media, and control-plane workflows
Deployment, monitoring, and readiness checks
Billing authority design beyond basic Stripe Checkout
Frontend-safe billing DTO design
Subscription lifecycle visibility
Builder ownership / context
This is implementation evidence, not generic product marketing.
Robert Schuelke is a self-taught builder who created this ecosystem while working full-time. The important signal is ownership across architecture, product decisions, debugging, deployment, and proof discipline.
Builder context
Robert Schuelke designed and implemented this six-app ecosystem across product architecture, frontend UX, backend APIs, centralized auth, billing authority, shared Supabase data modeling, deployment readiness, QA proof scripts, and AI-assisted product workflows.
System architecture
XFlow centralizes account, app routing, control-plane visibility, and auth handoff decisions.
Commercial authority
Verixet owns plans, checkout, usage admission, entitlement decisions, and billing lifecycle surfaces.
Shared data model
Supabase consolidation work is documented through schemas, migrations, rollout packets, and validation scripts.
Proof discipline
The repo includes static proof, smoke scripts, route checks, brand audits, readiness scripts, and generated proof artifacts.
My ownership vs AI assistance
AI is an acceleration tool inside human-owned engineering decisions.
The distinction matters for review: the architecture, product direction, boundaries, debugging calls, UX priorities, deployment decisions, and final implementation review are Robert-owned. AI assistance is used as leverage for implementation speed and review breadth.
Robert owns
Architecture decisions, product direction, system boundaries, debugging calls, UX priorities, deployment decisions, and final implementation review.
AI assistance accelerates
Coding, refactoring, documentation, testing ideas, and debugging support inside builder-directed implementation work.
Reviewer asset
Resume & Portfolio Snapshot
Download Robert Schuelke's full-stack developer resume covering the XFlow ecosystem, SaaS architecture, centralized auth, Stripe billing/entitlements, Supabase/PostgreSQL, AI product workflows, and selected product portfolio.
Proof artifacts
Evidence reviewers can trace back to commands and reports.
The engineering proof packet ties this public review page to the non-mutating proof harness, release checklist, generated JSON/Markdown reports, browser smoke scripts, shared Supabase validation, billing regression coverage, assistant proxy checks, and deployment readiness artifacts.
Static ecosystem proof harness
The root proof command validates contracts, public routes, XFlow to Verixet status behavior, billing DTO safety, usage catalog rules, usage ingest hardening, and satellite writer boundaries.
Latest static ecosystem proof harness
68 pass, 0 warnings, 0 failures. This represents one focused static proof run, not the full validation surface.
Release proof checklist
Merge, staging, and production promotion gates require proof artifacts, report review, and hard-blocker checks before release movement.
Protected HTTP smoke
HTTP proof is manual and staging-only. It is ready for GitHub environment configuration and does not run by default on pull requests.
Proof coverage matrix
The 68-pass harness is one layer of a broader proof surface.
This matrix lists repo-backed proof layers without converting run-specific artifacts into inflated totals.
Static ecosystem proof harness
- What it validates
- Contracts, public routes, XFlow to Verixet status behavior, billing DTO safety, usage catalog rules, usage ingest hardening, and satellite writer boundaries.
- Apps covered
- All six apps
- Evidence source
- scripts/phase17-ecosystem-proof.mjs; output/phase17-ecosystem-proof-report.md
- Status / caveat
- Latest static harness: 68 pass, 0 warnings, 0 failures. One focused static run, not the total validation surface.
Typecheck, lint, build
- What it validates
- Compile-time safety, lint discipline, and production build readiness across app workspaces.
- Apps covered
- Six-app ecosystem scripts
- Evidence source
- App package scripts and XFlow focused validation commands
- Status / caveat
- Available as runnable gates; report current command output rather than implying every historical run is green.
Public route verification
- What it validates
- Public routes, showcase chrome, footer/nav coverage, and no-localhost public links.
- Apps covered
- XFlow plus public app surfaces
- Evidence source
- apps/XFlow/tests/showcase-chrome.test.ts; scripts/smoke-public-ecosystem-pages.mjs; output/live-production-readiness-proof-2026-05-10.json
- Status / caveat
- Repo-backed. Public QA artifacts are run-specific and should be read with their recorded failures/caveats.
Browser smoke validation
- What it validates
- Rendered public pages, CTAs, responsive screenshots, metadata, and cross-app destinations.
- Apps covered
- All six public apps
- Evidence source
- scripts/smoke-public-ecosystem-pages.mjs; output/playwright and output/wordmark-qa artifacts
- Status / caveat
- Evidence exists, but browser smoke is live-environment-sensitive and not claimed as permanently green.
Brand casing audit
- What it validates
- Public-facing XFlow, Verixet, Rataify, AudAiX, WordGeni, and Crevux naming discipline.
- Apps covered
- All six public brands
- Evidence source
- scripts/audit-public-brand-casing.mjs
- Status / caveat
- Static audit gate; rerun before release.
Billing regression tests
- What it validates
- Plan selection, checkout routing, lifecycle summaries, frontend-safe status payloads, and Stripe catalog rationalization.
- Apps covered
- Verixet authority, XFlow consumers, satellites as billing consumers
- Evidence source
- apps/Verixet/src/lib/billing/*.test.ts; apps/Verixet/src/lib/commerce/*.test.ts
- Status / caveat
- Repo-backed regression coverage; no fake customer, revenue, or uptime metrics are inferred.
Entitlement and usage admission checks
- What it validates
- Usage catalog rules, Verixet-owned admission decisions, source-app restrictions, and sanitized satellite reporting.
- Apps covered
- Verixet, Rataify, AudAiX, WordGeni, Crevux, XFlow status surfaces
- Evidence source
- ecosystem-contracts/types/usage-metrics.ts; scripts/phase17-ecosystem-proof.mjs; usage ingest and reporter tests
- Status / caveat
- Static and unit-level proof surfaces are present; mutation endpoints are not called by the static harness.
Shared Supabase validation
- What it validates
- Shared schema direction, service-role boundaries, RLS proof, rollout packets, backup readiness, and app migration plans.
- Apps covered
- All six apps plus shared packages
- Evidence source
- scripts/validate-supabase-*.mjs; docs/shared-supabase-*.md; supabase/migrations
- Status / caveat
- Backed by scripts and docs; production cutover claims stay scoped to documented readiness state.
Assistant proxy smoke tests
- What it validates
- XFlow assistant proxy contracts, per-app service-token wiring, JSON envelopes, and support conversation routing.
- Apps covered
- XFlow, Verixet, Rataify, AudAiX, WordGeni, Crevux
- Evidence source
- scripts/smoke-ecosystem-assistant-production.mjs; docs/ecosystem-assistant-production-rollout.md; proxy smoke logs
- Status / caveat
- Smoke path exists; production runs depend on configured tokens and live app URLs.
Local persona/runtime proof
- What it validates
- Unauthenticated route access, protected route denials, role/persona route contracts, and non-mutating security simulation.
- Apps covered
- All six apps
- Evidence source
- scripts/authenticated-persona-security-simulation.mjs; output/authenticated-persona-security-simulation-2026-05-10.json
- Status / caveat
- Latest inspected artifact had 78 pass and 9 blocked authenticated personas due to missing env/cookies.
Deployment/readiness checks
- What it validates
- Production public routes, health/ready endpoints, Railway/Sentry env documentation, and launch readiness preflights.
- Apps covered
- All six deployed public surfaces
- Evidence source
- scripts/production-readiness-proof.mjs; scripts/verify-railway-sentry-env-docs.mjs; docs/observability/*; output/live-production-readiness-proof-2026-05-10.json
- Status / caveat
- Readiness evidence exists; no permanent uptime or certification claim is made.
| Proof layer | What it validates | Apps covered | Evidence source | Status / caveat |
|---|---|---|---|---|
| Static ecosystem proof harness | Contracts, public routes, XFlow to Verixet status behavior, billing DTO safety, usage catalog rules, usage ingest hardening, and satellite writer boundaries. | All six apps | scripts/phase17-ecosystem-proof.mjs; output/phase17-ecosystem-proof-report.md | Latest static harness: 68 pass, 0 warnings, 0 failures. One focused static run, not the total validation surface. |
| Typecheck, lint, build | Compile-time safety, lint discipline, and production build readiness across app workspaces. | Six-app ecosystem scripts | App package scripts and XFlow focused validation commands | Available as runnable gates; report current command output rather than implying every historical run is green. |
| Public route verification | Public routes, showcase chrome, footer/nav coverage, and no-localhost public links. | XFlow plus public app surfaces | apps/XFlow/tests/showcase-chrome.test.ts; scripts/smoke-public-ecosystem-pages.mjs; output/live-production-readiness-proof-2026-05-10.json | Repo-backed. Public QA artifacts are run-specific and should be read with their recorded failures/caveats. |
| Browser smoke validation | Rendered public pages, CTAs, responsive screenshots, metadata, and cross-app destinations. | All six public apps | scripts/smoke-public-ecosystem-pages.mjs; output/playwright and output/wordmark-qa artifacts | Evidence exists, but browser smoke is live-environment-sensitive and not claimed as permanently green. |
| Brand casing audit | Public-facing XFlow, Verixet, Rataify, AudAiX, WordGeni, and Crevux naming discipline. | All six public brands | scripts/audit-public-brand-casing.mjs | Static audit gate; rerun before release. |
| Billing regression tests | Plan selection, checkout routing, lifecycle summaries, frontend-safe status payloads, and Stripe catalog rationalization. | Verixet authority, XFlow consumers, satellites as billing consumers | apps/Verixet/src/lib/billing/*.test.ts; apps/Verixet/src/lib/commerce/*.test.ts | Repo-backed regression coverage; no fake customer, revenue, or uptime metrics are inferred. |
| Entitlement and usage admission checks | Usage catalog rules, Verixet-owned admission decisions, source-app restrictions, and sanitized satellite reporting. | Verixet, Rataify, AudAiX, WordGeni, Crevux, XFlow status surfaces | ecosystem-contracts/types/usage-metrics.ts; scripts/phase17-ecosystem-proof.mjs; usage ingest and reporter tests | Static and unit-level proof surfaces are present; mutation endpoints are not called by the static harness. |
| Shared Supabase validation | Shared schema direction, service-role boundaries, RLS proof, rollout packets, backup readiness, and app migration plans. | All six apps plus shared packages | scripts/validate-supabase-*.mjs; docs/shared-supabase-*.md; supabase/migrations | Backed by scripts and docs; production cutover claims stay scoped to documented readiness state. |
| Assistant proxy smoke tests | XFlow assistant proxy contracts, per-app service-token wiring, JSON envelopes, and support conversation routing. | XFlow, Verixet, Rataify, AudAiX, WordGeni, Crevux | scripts/smoke-ecosystem-assistant-production.mjs; docs/ecosystem-assistant-production-rollout.md; proxy smoke logs | Smoke path exists; production runs depend on configured tokens and live app URLs. |
| Local persona/runtime proof | Unauthenticated route access, protected route denials, role/persona route contracts, and non-mutating security simulation. | All six apps | scripts/authenticated-persona-security-simulation.mjs; output/authenticated-persona-security-simulation-2026-05-10.json | Latest inspected artifact had 78 pass and 9 blocked authenticated personas due to missing env/cookies. |
| Deployment/readiness checks | Production public routes, health/ready endpoints, Railway/Sentry env documentation, and launch readiness preflights. | All six deployed public surfaces | scripts/production-readiness-proof.mjs; scripts/verify-railway-sentry-env-docs.mjs; docs/observability/*; output/live-production-readiness-proof-2026-05-10.json | Readiness evidence exists; no permanent uptime or certification claim is made. |
Claim guardrails
What this page is not claiming
No unsupported compliance certification is claimed.
No invented customer, revenue, uptime, or scale metrics are used.
No static proof result is presented as a permanent production guarantee.
No claim is made that every live smoke artifact is currently green.
Protected staging HTTP proof remains separate from the static harness and is not described as complete unless the release checklist says so.
Architecture map
Six apps evaluated as one connected system.
This map is intentionally technical: it shows authority boundaries and product responsibilities instead of treating the ecosystem as a loose collection of landing pages.
Audit layerAudits, Lighthouse, accessibility, UX checks, monitoring/reporting, and regression visibility.
Writing intelligenceWriting intelligence, source-grounded content, publishing, and export workflows.
XFlowx / XFlowControl planeOperational control plane, app registry, auth authority, event visibility, routing, and assistant/control-plane workflows.
auth authorityevent ingestcross-app routingoperator visibility
Identity boundary
Auth and handoff model
- XFlow acts as the central auth authority for public sign-in and sign-up flows.
- Satellite apps delegate entry into XFlow instead of becoming separate auth authorities.
- App, source app, selected app, intent, and safe return URL context are preserved through handoff links.
- The design is OAuth-style/OIDC-style without claiming standards compliance beyond what is implemented.
Commercial boundary
Billing and entitlement model
- Verixet owns plans, checkout, workspace billing, and billing-state interpretation.
- Usage admission and entitlement decisions are Verixet-owned authority surfaces.
- Satellite apps consume entitlement state instead of creating their own billing authority.
- Pricing and checkout entry points stay routed toward Verixet-controlled plan decisions.
- Verixet does not treat every plan change as a simple checkout button. It includes preview-before-checkout safety, redundant/lower-tier purchase blocking, safe execution paths for known subscription items, lifecycle-aware billing dashboard states, and a frontend-safe billing status DTO that avoids exposing raw Stripe IDs to the browser.
Data boundary
Shared database / Supabase model
- The ecosystem is organized around shared identity, workspace, app, and product-context concepts.
- App-separated schemas keep product data separated while allowing shared platform-level patterns.
- Workspace scoping keeps user actions and operational records tied to the correct product context.
- Service-role boundaries are treated as authority boundaries, not casual frontend conveniences.
Release boundary
Production deployment model
- Readiness checks, route verification, status surfaces, and deploy proof are part of the product story.
- Environment and config readiness are treated as launch concerns instead of afterthoughts.
- Public domains, public routes, and cross-app links are validated for non-local production behavior.
- Monitoring concepts and operational review surfaces help explain what changed after release.
Trust boundary
Security model
- Authority boundaries separate XFlow operational control from Verixet billing authority.
- Workspace scoping, least-authority routing, legal/consent awareness, and audit trails are explicit concerns.
- Trust surfaces make security, privacy, support, status, and policy pages reviewable.
- Browser-safe DTOs keep billing visibility useful without exposing raw Stripe customer, subscription, or subscription item IDs.
- No unsupported compliance claims are needed; the proof is in the visible boundaries and workflows.
Verification boundary
Testing and QA strategy
- Typecheck, lint, build, route coverage, public route verification, and app-specific checks catch regressions.
- Chrome/nav/footer tests guard public positioning, footer coverage, and no-localhost link behavior.
- Brand casing audit protects public trust across XFlow, Verixet, Rataify, AudAiX, WordGeni, and Crevux.
- Browser smoke validation checks public pages, CTAs, breadcrumbs, JSON-LD, and cross-app destinations.
- Billing regression tests cover preview blocking, safe execution, lifecycle summaries, checkout validation, and frontend-safe status payloads.
AI/product features
AI is integrated into product surfaces, not presented as magic.
Robert uses AI-assisted development as leverage, but the architecture direction, product decisions, debugging, UX judgment, system boundaries, and final ownership are founder-directed.
Source-grounded writing workflows, claim review, project memory, and export-ready publishing flow.
Audit workflows for Lighthouse, accessibility, UX findings, launch readiness, and reporting.
Creative direction, image/video/storyboard generation, asset organization, and export workflows.
Assistant and control-plane workflows that connect events, readiness, and operator next actions.
Trust evidence workflows that turn public pages, policy checks, and issue evidence into proof surfaces.
Billing and governance workflows around plans, usage admission, entitlement state, and audit-ready decisions.
Screenshots and proof cards
Visible product evidence without fake metrics.
These cards use existing public assets from the repo. Where a full dashboard screenshot is not available, the proof is intentionally text-labeled rather than disguised as a fake screenshot.
XFlow app-directory proof card
Current screenshot asset missing.
No real current XFlow app-directory screenshot is available in the checked public assets. This card records the intended evidence target without presenting artwork or old imagery as a screenshot.
TODO: Add a real app-directory screenshot asset after capturing the current XFlow app directory.
Connected app cards
Integration dimensions status where backed by current app data
Policy/config status
Incident feeds
Agent status
Contract verification
Validation snapshots
Operational health
Control-plane proof
Shows the operating-layer concept behind connected events, readiness checks, and command-center visibility.
Billing authority proof
Represents the Verixet-owned commercial boundary for plans, checkout, entitlement decisions, and usage admission.
Trust surface proof
Represents customer-facing verification, public proof surfaces, issue evidence, and policy review concepts.
Audit/reporting proof
Represents launch-readiness audits, accessibility checks, responsive review, and regression reporting.
Writing workflow proof
Represents source-grounded writing, claim review, publishing support, and export-ready content workflows.
Media workflow proof
Represents prompt, reference, style, image/video/storyboard, asset library, and creative export workflows.
Links to all six apps
Review the ecosystem as shipped public surfaces.
All destinations are production-safe or internal XFlow showcase paths. No localhost links are used.
XFlowx / XFlow
Control plane
Open the central workspace hub to review app status, routing, readiness evidence, and operator workflows.
Open public app
Billing authority
Inspect the billing authority surface for plan governance, checkout handoff, usage limits, and entitlement proof.
Open public app
Trust proof
Review the trust layer for verification status, policy signals, reputation evidence, and public legitimacy checks.
Open public app
Audit layer
Check the audit product for launch-readiness reports, route evidence, accessibility checks, and monitoring output.
Open public app
Writing intelligence
Review the writing app for document workflows, source coverage, draft planning, and publish-ready content tools.
Open public app
Media workflows
Inspect the creative app for generation jobs, asset readiness, export flow, and media production review loops.
Open public appCan evaluate quickly
Questions this page is designed to answer quickly.
A hiring manager should not have to infer the technical depth from generic marketing language. This checklist turns the project into direct evaluation signals.
Can this person reason across frontend, backend, auth, billing, data, deployment, and product UX?
Is this more than a landing page?
Are authority boundaries defined?
Are there real public app surfaces?
Are there testing/proof workflows?
Are AI features integrated into product surfaces?
Are security and trust models considered?
Is there evidence of multi-app systems thinking?
Known next improvements
The next work is evidence depth, not inflated claims.
These are practical gaps to keep improving the reviewer path and authenticated product proof without weakening the no-fake-claims discipline.
Expand AudAiX and Rataify intelligence into each XFlow app card.
Add per-app operational evidence drawers.
Improve unauthenticated demo paths.
Continue shared Supabase rollout evidence.
Expose clearer protected-route smoke status.