echooo

Just talk, just snap — "echooo" helps turn it all into memories you can find again.

Comment

Inspiration

I have always wanted to document my life, but I could never find a method that truly suited me.

I don’t enjoy posting Stories on social media, and I don’t want every piece of my life to be shared publicly. But when I choose not to post, my photos, thoughts, voice notes, and life moments end up scattered across albums, chat histories, and notes. Even if I once saved them, after some time it becomes difficult to recall what actually happened.

The real problem is not a lack of things worth recording, but the high cost of organizing memories.

To properly document an experience, I would need to write it out, add context, tag people, categorize topics, and store it in the right place. This process takes time. For someone with a full-time job and a fast-paced life, this kind of effort is often postponed, and many meaningful moments are never preserved.

Most existing tools help us store information, but very few truly reduce the cost of organizing our lives.

That is why we built echooo: to allow people who don’t want to share publicly, and don’t have time to organize, to still capture their lives in a natural and low-effort way.

What it does

echooo is a private, voice-first space where users can naturally capture life stories, thoughts, and things they want to do in the future.

Its goal is to reduce the cost from “wanting to record something” to “being able to find it again later.”

Users don’t need to think about titles, categories, or formats in advance, nor do they need to sit down and write a formal journal entry. At any moment, if they recall an experience, a feeling, or something they want to do, they can simply speak it out and optionally attach a photo.

Recording does not require immediate organization. The content is first saved as a pending record, and later transformed into an editable draft. Users can review and confirm people, events, topics, stories, emotions, and follow-up actions, and then decide what becomes part of their memory.

The process is:

  1. Speak a story, optionally with a photo.
  2. Save the raw content as a pending record.
  3. Convert it into an editable draft.
  4. Review and modify people, topics, events, emotions, and follow-ups.
  5. Confirm and save it as a personal memory.
  6. Retrieve it later through natural voice queries or filtering.

When users want to find something again, they don’t need to remember exact titles, dates, or keywords. They only need to recall fragments that humans naturally remember—who they were with, how they felt, roughly when it happened, or what it was about.

echooo doesn’t just store content. It gradually turns scattered life fragments into a personal resource that can be revisited, searched, and used over time.

How we built it

Before implementation, we spent significant time on product and technical decisions.

We clearly defined the problem, the full user flow, and the data and privacy constraints the system must follow. We then used AI to help analyze requirements and compare possible technical approaches.

However, we did not rely entirely on AI for decisions. We prioritized frameworks we understood and trusted, ensuring we could validate system behavior and implementation quality even while using AI to accelerate development.

The frontend is built with React and Next.js, with a mobile-first experience. Recording is handled directly in the browser using the standard MediaRecorder API, so no extensions or native apps are required.

The backend uses Rust and Axum, handling authentication, data ownership isolation, media validation, external service requests, and deterministic search. PostgreSQL stores application state and limited-size media, managed through SeaORM and versioned migrations.

In the content processing pipeline:

  • Deepgram Nova-3 converts audio into text.
  • GPT-5.6 transforms transcripts into structured drafts for user review.
  • GPT-5.6 also converts natural language queries into strict, typed search filters.
  • Models never access the database directly or generate SQL.
  • All structured outputs are validated by the Rust backend before executing user-scoped PostgreSQL queries.
  • Photos are not processed by external AI systems.

Codex was involved in most of the development process, but not for generating isolated code snippets. Instead, we defined each task as a complete, long-running unit that delivers a usable product slice.

Each task includes:

  • The user problem it solves
  • Current system and code state
  • Scope of the task
  • Constraints that must not be broken
  • A clear definition of completion
  • Required tests and validations
  • Documentation and follow-ups

Through this approach, Codex contributed not only to code generation but also to full-stack implementation across frontend, backend, database, testing, and deployment. Docker and Docker Compose provide a reproducible self-hosted environment, and the judging version is deployed on an HTTPS server.

Challenges we ran into

Our biggest constraint was time.

Since I have a full-time job, I could only work on echooo during limited hours after work. Turning an idea with many unclear parts into a usable prototype under these conditions was the main challenge.

We adopted a strategy of using AI wherever it could accelerate progress. APIs, tools, and subscriptions were introduced whenever they improved productivity, and work was distributed across parallel threads covering product design, frontend, backend, database, testing, and deployment.

However, AI being able to implement does not mean implementation problems disappear.

The real challenge was enabling AI to complete long-running tasks that span multiple files and system boundaries without drifting away from the original requirements.

As tasks grow longer, AI may lose earlier constraints, misunderstand existing code, produce outputs that seem correct but don’t actually work, or break other parts of the system while fixing one issue. This shifted our focus from simply “building features” to:

  • Translating product requirements into tasks AI can reliably execute
  • Defining clear starting and completion conditions
  • Keeping parallel development threads consistent
  • Detecting issues through testing and real usage
  • Using AI to review and fix outputs generated by other AI processes
  • Ensuring long tasks can resume after interruptions

We gradually built systems such as project state tracking, task lists, session handoffs, validation checkpoints, and browser-based flow testing, so that each piece of work produces verifiable results rather than just code that appears complete.

Beyond development time, the product itself presented key challenges.

First, how to help organize personal memories without letting the system decide what is true. echooo separates raw records, structured drafts, and user-confirmed memories, ensuring only the user determines what becomes part of their history.

Second, how to safely handle natural language search. Since user queries can be vague, the model is restricted to producing strictly defined filters. The backend rejects invalid outputs and executes only deterministic, user-scoped queries.

Third, how to provide a reliable recording experience in mobile browsers, including handling permission denial, interruptions, size and time limits, retries, draft editing, and recovery from failures.

The biggest engineering challenge was not just using AI to build quickly, but creating a development process where AI-generated work can be continuously validated, corrected, and extended.

Accomplishments that we're proud of

What we are most proud of is that, within a very limited amount of time, we turned a problem we had repeatedly experienced into a product that actually works.

echooo did not begin with a perfectly defined specification. It started from a personal frustration: wanting to preserve meaningful parts of life, but rarely having the time or motivation to organize them. Many parts of the solution were still unclear when development began.

As we built the product, the problem gradually became more concrete. What initially seemed like several separate issues—capturing thoughts, organizing memories, tracking things we want to do, and finding old records—came together into one connected experience.

The result is a complete working loop:

capture → organize → review → confirm → retrieve

Users can record a story, turn it into a structured and editable draft, decide what should become part of their confirmed history, and later retrieve it using the incomplete clues people naturally remember.

Some parts of the current implementation are still prototype-stage workarounds, but the core experience genuinely functions. It is not only a concept, mockup, or prerecorded demonstration.

For us, the most meaningful accomplishment was proving that this personal pain point could become a usable product—and completing that product within the time constraints of the hackathon.

What we learned

Building echooo changed how we think about both the product problem and the software development process.

From a product perspective, we learned that the problem is larger than simply transcribing voice notes or searching old records.

People already have many ways to capture information. The real difficulty is the effort required to turn scattered fragments into something meaningful, organized, and retrievable. When capture, organization, confirmation, and retrieval are connected in one flow, those fragments can gradually become a personal information system rather than another collection of forgotten files.

We also learned that organization should not require users to fully understand the importance of a moment when they first record it. People should be able to capture something quickly and decide how it fits into their lives later.

From an engineering perspective, this was the first time in a long while that we had completed such an intensive product sprint within a short period.

The capabilities of current AI development tools are significantly stronger than what we had previously experienced. They can contribute not only to isolated pieces of code, but also to longer tasks involving multiple files, system boundaries, tests, migrations, and browser behavior.

This changed the skills we needed to focus on. The challenge was no longer only writing every line manually. It became equally important to describe the problem clearly, choose appropriate tools, define task boundaries, establish completion criteria, validate results, and preserve enough project context for work to continue reliably.

For a time-constrained sprint like this, failing to make full use of AI-assisted development would mean giving up a substantial productivity advantage. However, increased implementation speed also makes human judgment more important. Product direction, architecture, privacy boundaries, quality standards, and final verification still need clear human ownership.

Most importantly, we learned that personal technology should reduce the effort required to understand and preserve our lives—not create another system that demands constant maintenance.

What’s next for echooo

The current direction of echooo is still largely based on our own experiences and assumptions. The most important next step is to understand whether the product fits naturally into other people’s lives.

We have already deployed a working version and invited a small group of friends to try it. Based on their experience, we plan to complete one or two rounds of iteration before deciding on the shape of a broader release.

The first round of testing will focus on several fundamental questions:

  • Will people naturally use voice to capture personal moments over time?
  • Is the review and confirmation process lightweight enough?
  • Which parts of a memory are useful to structure, and which should remain as an open narrative?
  • What clues do people actually use when trying to retrieve something later?
  • Does echooo feel like a helpful private space, or another tool that requires maintenance?

Data ownership and storage will also be an important part of the next stage. Personal memories are highly sensitive, so we want to explore stronger encryption, clearer export and deletion controls, local or user-controlled storage, and self-hosted options. The long-term goal is for users to have meaningful control over where their memories live and how they are processed.

Beyond individual memories, echooo could gradually build longer-term personal context. Future versions may help users follow unfinished intentions, recurring topics, changing relationships, and ideas that develop across multiple entries.

We also want to make recaps more meaningful. The current prototype can summarize relatively simple sets of records, but future versions could connect memories across a week, month, or longer period—identifying recurring people, emotions, themes, and changes over time.

The goal is not to generate more summaries for users to read. It is to help them notice patterns they might otherwise miss, resurface unfinished things at useful moments, and turn scattered records into a clearer understanding of their own lives.

Built With

Share this project:

Updates