Privato

Digital vaults organize files. Privato organizes trust, organizing and sharing your most important documents, insurance cards, medical details, and emergency contacts with people you trust.

Comment

Inspiration

Privato began with a problem inside my own family.

My wife and I have four children, and over the years we have accumulated a growing collection of information they may need: emergency contacts, insurance cards, vehicle information, medical details, household instructions, and other important family records.

Some of it lives in a shared spreadsheet. Some is stored in email. Some is buried in text messages, cloud folders, wallets, filing cabinets, and photos on our phones.

The information exists—but it is fragmented.

That creates a difficult question:

If something happened tonight, would the right people know where everything is?

Most digital vaults are designed around files, folders, and individual permissions. Families do not naturally think that way. We think in relationships:

  • My spouse should have access to nearly everything.
  • My children should have the information that keeps them prepared.
  • A trusted friend may need emergency instructions, but not financial records.
  • A caregiver may need medical information without seeing the rest of the family vault.

That insight became the foundation of Privato:

Digital vaults organize files. Privato organizes trust.

What Privato does

Privato is a private information network that helps families and trusted contacts organize sensitive household information and share it intentionally with the right people.

Instead of managing access one document at a time, users organize people into three concentric trust circles:

  • Core Circle — the people closest to you, such as a spouse or partner
  • Inner Circle — trusted family members, including children or close relatives
  • Outer Circle — friends, caregivers, advisors, or other trusted contacts

Resources are then assigned a visibility level.

A person’s circle determines which information they can access. Moving someone into or out of a circle immediately changes their effective permissions without requiring the owner to resend files, rebuild folders, or manually revise every resource.

Privato can organize information such as:

  • Health and automobile insurance cards
  • Emergency contacts
  • Medical summaries
  • Vehicle registrations
  • Roadside-assistance information
  • Household emergency instructions
  • Identity, financial, and legal records
  • Any other information a family may need during an important moment

The experience is designed to feel calm, understandable, and human—not like enterprise access-control software.

The experience

The Privato dashboard gives each household a clear view of:

  • Important family resources
  • Who belongs to each trust circle
  • Which resources are expiring
  • What the current identity can access
  • The household’s overall preparedness
  • Recent, non-sensitive activity

The central experience is intentionally relationship-aware.

A user can move a household member between circles and preview exactly what that person will gain or lose before confirming the change. Privato also includes a demo identity switcher, making it possible to view the application as another household member and verify that each person sees exactly what they should—and nothing else.

The experience is fully responsive across desktop and mobile, preserving the same authorization behavior, resource visibility, and Ask Privato capabilities on every screen.

Ask Privato

Ask Privato is the project’s defining AI capability.

A household member can ask practical questions such as:

  • “What number do I call for roadside assistance?”
  • “When does the Honda insurance expire?”
  • “Where is Mom’s health-insurance information?”
  • “Who should I contact during an emergency?”
  • “Do we have towing coverage?”

Privato answers using only information the current person is already authorized to access.

The security sequence is deliberate:

Authorization first. Retrieval second. AI last.

Before generating an answer, Privato:

  1. Resolves the active identity on the server
  2. Confirms household membership
  3. Calculates the person’s authorized resource scope
  4. Searches only within that permitted scope
  5. Decrypts only the selected authorized evidence
  6. Sends the minimum relevant context to OpenAI
  7. Validates the model’s structured response and citations
  8. Returns a grounded answer linked to the supporting Privato resources

The model never decides whether someone should see private information.

Restricted resources never enter the answer model’s context.

Revocable, identity-aware AI retrieval

The most important demonstration in Privato uses the same question across different identities.

An authorized household member can ask for the roadside-assistance number and receive a grounded response with a citation.

A person in the Outer Circle can ask the exact same question and receive:

“I couldn’t find accessible information that answers that question.”

Privato does not reveal that a restricted resource exists, who can access it, or which circle would be required.

When that person is moved into the Inner Circle, the same question immediately becomes answerable. Moving them back to the Outer Circle removes access again.

This demonstrates that AI retrieval is not based merely on what exists in the household vault. It is based on what the current identity is permitted to know at that exact moment.

No-evidence fast path

When no authorized evidence supports a question, Privato does not invoke the generative answer model.

This reduces unnecessary cost and latency while ensuring that inaccessible information is never sent upstream and then filtered after generation.

The safest AI authorization decision is the one the model never receives.

Grounded citations

Successful answers cite the Privato resources used as evidence.

Citation links are generated and validated by the application—not invented by the model—and opening a cited resource rechecks authorization through the same policy boundary.

How this answer was protected

Each Ask Privato result includes a collapsible protection trace showing safe operational details such as:

  • Active identity
  • Current trust circle
  • Authorized resource count
  • Candidates considered
  • Sources used
  • Policy outcome
  • Retrieval method
  • Whether the answer model was invoked
  • Model name
  • Runtime duration
  • Retry count
  • Circuit state
  • Token usage
  • Correlation ID

The trace intentionally excludes prompts, decrypted evidence, policy numbers, medical information, restricted resources, encryption keys, and internal database identifiers.

It makes Privato’s privacy model visible and understandable without exposing the information it is designed to protect.

AI-assisted document organization

Privato also reduces the work required to add important information.

Users can upload an insurance card or enter a resource manually. The AI-assisted workflow can:

  • Identify the document type
  • Extract structured information
  • Highlight uncertainty
  • Suggest an appropriate trust circle
  • Present every field for review and correction

The user remains in control.

AI can recommend how a document should be organized, but it cannot silently save the resource, assign access, or make a trust decision. The user reviews both the content and its intended audience before approval.

AI reduces administrative burden without becoming the authority.

How I built it

I built Privato as a focused, production-shaped vertical slice using:

  • Next.js and the App Router
  • React
  • TypeScript
  • Tailwind CSS
  • PostgreSQL
  • Drizzle ORM and Drizzle Kit
  • OpenAI
  • Zod
  • ElectriPy AI runtime controls

The application is organized around explicit domain and application boundaries for:

  • Household membership
  • Demo identity resolution
  • Trust circles
  • Resource visibility
  • Authorization
  • Encryption and decryption
  • Document storage
  • Permission-scoped retrieval
  • AI provider integration
  • Runtime resiliency
  • Audit events
  • Safe telemetry

Circle-based authorization is deterministic and centralized rather than duplicated throughout the interface, route handlers, database queries, and AI logic.

The same policy governs:

  • Vault browsing
  • Resource detail pages
  • Direct URL access
  • Sensitive-value retrieval
  • Document access
  • Ask Privato evidence retrieval
  • Citation navigation

The AI layer sits behind an application boundary so provider behavior, structured validation, retries, timeouts, circuit breaking, telemetry, and fallback behavior remain separate from the core domain.

ElectriPy introduces production-oriented runtime discipline around AI operations, including bounded failure handling, safe telemetry, structured validation, correlation, and graceful fallback behavior.

The architecture is intentionally designed so AI operates inside deterministic policy boundaries rather than becoming responsible for security decisions.

Permission-scoped retrieval

Ask Privato is not implemented as a generic chatbot over the entire household vault.

The retrieval pipeline begins with the current person’s authorized resource scope.

Only then does Privato rank relevant resources and construct small evidence packets containing the minimum information required to answer the question.

Conceptually, the pipeline is:

Trusted identity
    ↓
Household membership
    ↓
Central authorization policy
    ↓
Authorized resource scope
    ↓
Permission-filtered retrieval
    ↓
Decrypt selected evidence
    ↓
OpenAI grounded answer
    ↓
Server-side citation validation
    ↓
Protected response

This prevents the common failure mode in which an AI system retrieves everything first and attempts to hide restricted information afterward.

Privacy and security

Privato handles information that families consider deeply sensitive, so security could not be treated as a visual feature or deferred concern.

The architecture is based on:

  • Least-privilege access
  • Server-side identity resolution
  • Deterministic circle-based authorization
  • Cross-household isolation
  • Owner-only private resources
  • Permission-filtered retrieval
  • Decryption only after authorization
  • Validated user input
  • Validated model output
  • Server-side citation validation
  • Encrypted sensitive data
  • Explicit approval before extracted information is stored
  • Restricted AI retrieval context
  • Safe audit records
  • No private evidence in operational telemetry
  • Neutral responses that do not reveal restricted-resource existence
  • Immediate permission recalculation after circle changes

Privato also treats stored document content as untrusted data. Resource text cannot override system instructions, change authorization policy, reveal hidden prompts, or instruct the model to access information outside the evidence supplied by the application.

The Build Week version is a prototype. It does not claim formal regulatory compliance, zero-knowledge architecture, end-to-end encryption, or independently audited security.

However, its core authorization, retrieval, encryption, and AI boundaries were designed to reflect how a production system handling sensitive family information should be structured.

Authorization-aware AI evaluations

I added focused tests and evaluation scenarios around the areas most likely to fail in a privacy-sensitive AI system.

These include:

  • Owner access to private resources
  • Core, Inner, and Outer inheritance
  • Cross-household access denial
  • The same question asked by different identities
  • Immediate access grants after a circle change
  • Immediate revocation after moving someone back
  • No-answer behavior when authorized evidence is unavailable
  • Verification that the answer model is skipped when no evidence exists
  • Rejection of fabricated model citations
  • Direct URL guessing
  • Requests naming an exact restricted resource
  • “Ignore your permissions” prompt-injection attempts
  • Requests to impersonate another household member
  • Prompt injection stored inside a document
  • Identity-state isolation after switching users
  • Authorization checks before decryption

The goal was not merely to prove that authorized answers work.

It was equally important to prove that unauthorized answers do not.

The challenge

I had one day to build what was originally intended to be a week-long project.

That constraint forced an important product decision: do not build a wide but shallow digital vault.

Instead, I focused on one complete and coherent story:

  1. Enter a prepared household
  2. Understand its Core, Inner, and Outer Circles
  3. View shared family resources
  4. Add and organize sensitive information
  5. Change a person’s trust-circle membership
  6. See their effective access change immediately
  7. Ask the same question as different identities
  8. Prove that authorized information is easy to retrieve
  9. Prove that unauthorized information remains unavailable
  10. Explain exactly how each AI answer was protected

The hardest part was balancing three goals that often conflict:

  • A simple consumer experience
  • A meaningful authorization model
  • A sophisticated AI capability that could be demonstrated clearly

The concentric-circle metaphor became the bridge between them. It gives families an intuitive mental model while preserving deterministic access control underneath.

The second major challenge was ensuring that AI convenience never weakened that model.

Privato had to make permitted information effortless to retrieve while ensuring that inaccessible information never entered the model context at all.

What I learned

The strongest lesson was that privacy products cannot rely on technical security alone.

People need to understand:

  • Who can see something
  • Why they can see it
  • What changes when a relationship changes
  • Whether access has actually been removed
  • How an AI answer was produced
  • Which resources supported it

Security must be visible, understandable, and predictable.

I also learned that AI becomes more trustworthy when its authority is intentionally constrained.

Privato does not ask a model to determine trust. It uses AI only after the application has established what the current person is allowed to know.

The model receives evidence, not authority.

That separation makes the experience safer, easier to explain, and more technically credible.

How I used OpenAI and Codex

Codex was the primary engineering environment through which I built Privato, with GPT-5.6 serving as the development-time reasoning and implementation model.

I approached the collaboration as a senior architect working with an implementation agent—not as a one-sentence prompt followed by an unaudited code dump. I have decades of experience across full-stack engineering, enterprise architecture, distributed systems, cloud infrastructure, and production AI systems, and I am joining Streamline Healthcare Solutions as a Lead AI Software Engineer. That background shaped the quality and specificity of the inputs I gave Codex.

My initial prompts were detailed architectural briefs covering the product thesis, relationship-aware trust model, authorization invariants, domain boundaries, Next.js and TypeScript conventions, PostgreSQL and Drizzle persistence, OpenAI integration, serverless deployment constraints, runtime resilience, responsive behavior, adversarial security scenarios, and acceptance criteria.

I retained ownership of the consequential product and engineering decisions:

  • Authorization must occur before retrieval and before model invocation.
  • The model must never decide what a person is authorized to access.
  • Restricted evidence must never enter the model context.
  • Unauthorized and nonexistent resources must produce the same neutral behavior.
  • Citations must be validated and reauthorized by the application.
  • AI should not be invoked when no authorized evidence exists.
  • The Build Week submission should be a narrow, complete vertical slice rather than a broad collection of incomplete features.

Codex translated those decisions into a coordinated implementation across the repository. It accelerated domain modeling, centralized authorization, PostgreSQL and Drizzle integration, responsive interface development, the Ask Privato orchestration pipeline, Structured Outputs, runtime resilience, safe telemetry, security-focused tests, documentation, and production verification.

The most valuable capability was Codex’s ability to preserve interconnected constraints across multiple layers. A change to identity or trust-circle membership had implications for dashboard filtering, direct resource access, decryption, AI retrieval, generated citations, and audit behavior. Codex could reason across those boundaries rather than treating each feature as an isolated code-generation task.

When I encountered an issue or suspected an edge case, I could bring Codex the observed behavior, the intended invariant, and the architectural context. It could inspect the relevant call path, formulate a likely root cause, modify the implementation, strengthen regression coverage, and run the repository’s linting, type-checking, tests, migration validation, and production build until the behavior was verified.

Codex also integrated naturally with my local development workflow. It worked through the repository, terminal, package scripts, Git state, database tooling, and hosting environment, significantly reducing the friction between reasoning about a change, implementing it, and validating the result.

Most repository engineering took place in Codex. ChatGPT was also used for selected product and feature discussions, visual ideation, image generation, and submission communication.

GPT-5.6 and Codex were development tools used to reason about and construct Privato. The running application separately uses the OpenAI Responses API and Structured Outputs for permission-scoped answers and assisted document organization. In production execution, deterministic application policy—not the model—continues to control identity, authorization, evidence selection, and access.

The strongest outcome was not simply that Codex produced code quickly. It was that Codex could accept large, precise architectural instructions, carry them across a non-trivial application, participate in evidence-driven debugging, use the local engineering toolchain, and repeatedly verify that the implementation preserved the intended boundaries.

That collaboration made it possible to take Privato from a carefully articulated product and architecture concept to a polished, tested, and deployed vertical slice within a one-day Build Week implementation window.

What I am proud of

I am proud that Privato does not feel like a generic file manager, AI chatbot, or hackathon dashboard.

Its visual identity, concentric-circle interaction model, responsive experience, deterministic authorization architecture, and permission-scoped AI all reinforce the same idea:

The right information should reach the right people before an emergency happens.

I am especially proud of the same-question, different-identity demonstration.

It makes an invisible security boundary visible:

  • Authorized users receive useful, grounded answers.
  • Unauthorized users receive no private information.
  • Moving someone between circles changes AI retrieval immediately.
  • The model never becomes the decision-maker.

Privato turns a scattered family spreadsheet into a living preparedness system built around trust.

What is next

The next version of Privato could introduce:

  • Temporary and time-limited access grants
  • Family invitations
  • Passkey authentication
  • Secure account recovery
  • Recovery delegates
  • Expiration reminders
  • Emergency packets
  • Caregiver workflows
  • Additional document types
  • Client-side key management
  • Native mobile applications
  • Independent security review

The long-term vision is larger than document storage.

Privato can become the private coordination layer families rely on when information is important, time is limited, and trust matters most.

Built With

Share this project:

Updates