
Hey everyone 👋

Meet Jotley — a native voice notes app for Mac and iOS with real-time AI transcription. This is my first "building in public" post, so let me catch you up on where things stand and why I'm taking the approach I am.

## The One-Liner

**Jotley is what Apple Notes would be if it could transcribe your voice, summarize it with AI, and let you chat with your notes.** Record a thought, get a transcript and summary instantly. Ask questions about what you recorded. Syncs across all your devices.

👉 **[jotley.ai](https://jotley.ai)**

## Why Native SwiftUI (and why this matters)

This is probably the most opinionated decision I made early on, and I want to be honest about the trade-offs.

### Why not Electron/React Native?

I've used plenty of Electron apps. Notion, Slack, Discord — they work, but you *feel* it. The memory usage, the slight input lag, the way they just don't integrate with the OS the way native apps do.

For a notes app that I want people to reach for 20+ times a day, native performance isn't optional. It's the product.

**The honest trade-off:** I'm targeting maybe 30% of the smartphone market (Apple users only). That's a real limitation. But I'd rather build something *excellent* for a smaller market than something mediocre for everyone.

But here's the real reason: **this app simply wouldn't be possible with cross-platform frameworks.**

When you're building a voice-first app that needs to:
- Capture system audio on Mac (requires Apple's ScreenCaptureKit and ProcessTap APIs)
- Handle real-time audio streaming with AVFoundation
- Integrate deeply with iCloud sync via CloudKit
- Feel like a first-class citizen on both platforms

...there's no React Native bridge for that. These are Apple-only SDKs that require native Swift code. I could've built a lesser version with cross-platform tools, but the core features that make Jotley special wouldn't exist.

### The 60/40 code split

Here's something I'm proud of: **~60% of my codebase is shared between iOS and macOS.** Views, models, services, sync logic — all shared. Platform-specific stuff (system audio capture on Mac, voice recording on iOS) lives in separate directories.

This wasn't automatic. It took deliberate architecture work. But now when I add a feature, I usually only write it once.

## The Architecture (High Level)

Native SwiftUI apps talking to a lightweight backend that handles transcription and AI. The apps stream audio, the backend processes it, transcription and summaries come back in real-time.

Why a backend at all? API key security, usage tracking, and the ability to ship new AI features without waiting for App Store review.

## The Development Journey

### What took longer than expected:

1. **CloudKit sync** — Getting conflict resolution right is *hard*. When you delete a note on Mac while your iPhone is offline, what happens when it comes back online? I went through three different sync strategies before landing on one that feels reliable.

2. **System audio capture on Mac** — This requires special entitlements from Apple and involves newer APIs (ScreenCaptureKit, ProcessTap). Getting screen recording permission flow to feel native took iteration.

3. **Real-time transcription feel** — The words need to appear smoothly as you speak. Too chunky feels broken. Too fast feels jittery. Finding the right buffering took trial and error.

### What was easier than expected:

1. **SwiftUI in 2026** — It's actually mature now. Most of the jank from early versions is gone. I'm building features, not fighting the framework.

2. **Transcription quality** — Modern speech-to-text is genuinely excellent. Fast and accurate out of the box.

## Honest Self-Assessment

**What I'm doing right:**
- Building something I actually use daily
- Native performance is a real differentiator
- The core experience (record → transcribe → summarize → chat) is tight

**What I'm doing wrong:**
- Zero marketing execution
- No content, no social presence, no audience
- "Build it and they will come" is not a strategy

## What's Next

I'm treating this month as the start of the real push:

1. **Record a demo video** — 60-90 seconds showing the core flow
2. **Update App Store screenshots** — Current ones don't show transcription
3. **Start posting on Indie Hackers** — You're reading post #1
4. **Ship the payment integration** — Can't be indie hacking at $0 MRR forever

## Questions for the Community

1. **Pricing thoughts?** I've got two tiers: **Essential** ($10/month or $79/year — works out to ~$6.50/month) and **Unlimited** ($20/month or $158/year — ~$13/month). Otter.ai charges $16.99/month. Am I positioned right?

2. **Product Hunt timing?** Do I launch now with what I have, or wait until the demo video and updated assets are ready?

3. **What would make you try it?** Genuinely curious what would get you to download a new notes app in 2026.

---

If you want to follow along: I'm **@braddunlap** on X/Twitter, and I'll be posting updates here regularly.

Sign up for early access at **[jotley.ai](https://jotley.ai/waitlist)** — we're launching soon!

Thanks for reading. Happy to answer any questions about SwiftUI, native dev, or indie dev life in general. 🙏


Building in public - a native voice notes app for Mac and iOS with real-time AI transcription and summaries.

Meet Jotley - Building a Native Apple Notes App with AI Transcription


<img src="/images/jetbot.png" alt="JetBot Orin Nano" style={{ width: '70%', height: 'auto', display: 'block' }} />

## About Project NVIDIA JetBot (Orin Nano) 

[JetBot (jetbot.org)](https://jetbot.org) is an educational robot platform originally designed for the now-discontinued Jetson Nano. While the newer NVIDIA Jetson Orin Nano Super Developer Kit (8GB) offers significantly more computing power, the official JetBot project hasn't been updated since February 2021. The existing documentation only provides an outdated parts list for the Orin Nano, with no software support outside of some other forked repos.

<div style={{ padding: '1rem 1.5rem', backgroundColor: '#2a2a2a', borderLeft: '4px solid #ff8c29', borderRadius: '0.375rem', margin: '1.5rem 0', color: '#e0e0e0' }}>
  <strong style={{ color: '#ff8c29' }}>Project Goal:</strong> Fully adapt the JetBot platform to work with the newer, more powerful NVIDIA Jetson Orin Nano, including all necessary hardware modifications, software updates, and Jupyter notebook compatibility.
</div>

<div style={{ padding: '1rem 1.5rem', backgroundColor: '#2a2a2a', borderLeft: '4px solid #ff8c29', borderRadius: '0.375rem', margin: '1.5rem 0', color: '#e0e0e0' }}>
  <strong style={{ color: '#ff8c29' }}>📦 Full Source Code:</strong> All updated code, configuration files, and Docker containers are publicly available in my forked GitHub repository at <a href="https://github.com/protomota/jetbot-orin" style={{ color: '#ff8c29', textDecoration: 'underline' }}>github.com/protomota/jetbot-orin</a>
</div>

After extensive testing and code modifications, I successfully adapted JetBot to run on the Orin Nano, including all the original Jupyter notebooks. This post shares my implementation to help others build their JetBots with the newer hardware.


## JetBot in Action

Here's the modified JetBot Orin Nano demonstrating autonomous navigation on a toy roadway using vision-based training and machine learning. The robot uses its camera to detect road boundaries and navigate the course in real-time, showcasing the practical capabilities of the Orin Nano's enhanced computing power for inference and decision-making.

<div style={{ position: 'relative', paddingBottom: '56.25%', height: 0, overflow: 'hidden', maxWidth: '100%' }}>
  <iframe
    style={{ position: 'absolute', top: 0, left: 0, width: '100%', height: '100%' }}
    src="https://www.youtube.com/embed/gLUGdiM5JT8?si=kxT0JD-wGJJjR5er"
    title="JetBot Orin Nano Autonomous Navigation"
    frameBorder="0"
    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
    allowFullScreen
  />
</div>

## The Power Challenge

The biggest hurdle I encountered was the power requirements. The original Nano runs on 5V, while the Orin Nano requires 9-20V. Combined with the motor controller and motor requirements, standard 10,000mAh USB power banks can't deliver this higher voltage reliably. You can power one or the other, but not both. After testing numerous options (and making far too many returns to Amazon), I decided that the best and easiest solution would be dual power banks: one for the Orin Nano and one for the motors and controller. While this adds weight and complexity, the plus side is longer runtime. Until someone starts selling a custom Power Delivery Board desinged for the Orin Nano, this is the best solution I could come up with.

## Model Redesign

This presented another problem - the original chassis model only fits one battery. So I needed to modify the battery compartment area of the model to support dual 10,000mAh batteries and then reprint it.

<img src="/images/jetbot_chassis.png" style={{ width: '70%', height: 'auto', display: 'block' }} />

**Download the modified chassis with printer settings:** [chassis-dual.3mf](/stls/chassis-dual.3mf)

**Download STL only:** [chassis-dual.stl](/stls/chassis-dual.stl)

## Updated Bill of Materials for JetBot Orin Nano

While the JetBot community has updated the [parts list for the Orin Nano](https://jetbot.org/master/bill_of_materials_orin.html), the current recommendations are partially outdated and don't properly address the power requirements. While most of the instructions in the parts list are accurate and you will need the parts, the instructions will only get you 80% there. There are many broken links and outdated recommendations. Here are my recommended improvements:

### NVIDIA Jetson Orin Nano
- **Developer Kit**: [NVIDIA Jetson Orin Nano Super Developer Kit (8GB)](https://a.co/d/25PFWsQ) - Our robot brain.

### Power Solution
- **Power Banks**: 2 x [35W 10,000mAh Power Bank](https://a.co/d/7xAGgzn) - You need two of these. One for the Orin Nano, and one for the motors and motor controller. The larger wattage on this model is also essential for meeting the Orin Nano's higher power demands. 35W will also allow you to run the Orin Nano at full 25W power. This particular model is available under a couple of different names as it is a white label product. This one is particularly cool as the power reading buttons and readout conveniently fit perfectly in the windows of the JetBot.
- **Power Adapter**: [USB-C to DC Adapter](https://a.co/d/dkdyue0) - Much cleaner and more compact solution without cable management headaches of the recommended 6-foot cable.
- **USB-C Cable**: [Short USB-C Cable](https://a.co/d/4MnorER) - This plugs into the battery and the power adapter.

### Storage Upgrade
Instead of an SD card, I strongly recommend upgrading to an [NVME M.2 SSD](https://a.co/d/eRiWrBd). This provides significantly better performance and reliability.

**Important**: Installing Jetpack on the Orin Nano with an SSD requires a host x86 PC running Ubuntu for the reflashing process. ARM-based systems like Raspberry Pi won't work for this.

If you don't have an x86 Ubuntu machine, you can purchase an [affordable mini PC](https://a.co/d/1Lq3vmM) for about the same cost as a Raspberry Pi. Install Ubuntu alongside or instead of Windows for the setup process.

I had the idea that it might work in an Ubuntu virtual machine, but I don't know if that is supported. Something to try if you need to.

## Getting Started

Follow the [NVIDIA Jetpack SDK Installation Instructions](https://docs.nvidia.com/jetson/jetpack/install-setup/index.html) to install the latest Jetpack on your Jetson Orin Nano.

### Hardware Setup and Motor Controller Configuration

Before running the software, ensure your hardware is properly configured:

#### Motor Controller Power

The Adafruit MotorHAT/FeatherWing motor controller requires **external power** (6-12V) separate from the Jetson.

**Important**: Check that the motor controller has a **green power LED lit at all times**. Some power banks automatically shut down if they detect low current draw, thinking nothing is connected. If you're using a power bank:
- Use a power bank that supports low-current devices
- Monitor the green LED - if it turns off, your power source has shut down
- NVIDIA does not yet have an official recommendation or solution for powering the Orin Nano from a dedicated battery pack designed for robotics. It is possible, but outside the scope of this tutorial. Venture at your own risk as it has its own set of technical challenges.

#### Connecting to your NVIDIA Orin Nano

Open your terminal and SSH into your Orin Nano:

```bash
ssh jetbot@<jetbot_ip>
```

#### I2C Bus Configuration

Since the Orin Nano I2C bus is different (7, rather than the default 1), you need to set the `JETBOT_I2C_BUS` environment variable:

```bash
# Add to ~/.bashrc for persistence
echo 'export JETBOT_I2C_BUS=7' >> ~/.bashrc
source ~/.bashrc
```

#### Installing the JetBot Python Package

Create a directory called 'source' in your home directory:

```bash
cd ~
mkdir source
```

**IMPORTANT**: Clone my forked and updated repository that works with the Orin Nano hardware:
```bash
cd source
git clone https://github.com/protomota/jetbot-orin.git
```

Install the JetBot Python package:

```bash
cd jetbot-orin
python3 setup.py install --user
```

### Configure System

First, run the `scripts/configure_jetson.sh` script to configure the power mode and other parameters.

```bash
cd ~/source/jetbot-orin
./scripts/configure_jetson.sh
```

### Configure Docker Environment

Navigate to the docker directory and source the `configure.sh` script to configure environment variables.

```bash
cd docker
source configure.sh
```

### Build Docker Containers

Build all JetBot containers from scratch:

```bash
./build.sh
```

This step is required before running the containers for the first time.

### Enable and Start Containers

Enable Docker to start at boot and launch the JetBot containers:

```bash
./enable.sh $HOME
```

The directory you specify (e.g., `$HOME`) will be mounted as `/workspace` in the Jupyter container. All work saved in `/workspace` will persist across container restarts.

### Access Jupyter Lab

Open your web browser and navigate to:

```
https://<jetbot_ip>:8888
```

The default password is `jetbot`.

<img src="/images/jupyterlab.png" alt="JupyterLab Interface" style={{ width: '70%', height: 'auto', display: 'block' }} />

## Optional Configuration

### Enable JetBot Python API Support

Run setup (optional, but recommended - only needed if you plan to use JetBot Python APIs outside of Docker):
```bash
cd ~/source/jetbot-orin
python3 setup.py install --user
```

### Power Mode (Jetson Orin Nano 8GB)

For **Jetson Orin Nano 8GB Developer Kit**, we recommend lowering the power mode to 3W for optimal battery operation:

Common Orin Nano power modes:
  - Mode 0: MAXN (15W/20W depending on your module)
  - Mode 1: 10W mode (power-saving)
  - Mode 2: 15W mode
  - Mode 3: 7W mode

```bash
sudo nvpmodel -m 3
```

Then verify it worked:

```bash
sudo nvpmodel -q
```

## Managing Containers

### Stop All Containers

```bash
cd docker
./disable.sh
```

### Rebuild Containers

```bash
cd docker
./disable.sh
./build.sh
./enable.sh $HOME
```

## Important Notes

- The containers will restart automatically on boot
- Work saved outside of `/workspace` in the Jupyter container will be lost when the container restarts
- The NVIDIA runtime is automatically configured by `configure.sh`
- Docker daemon is automatically enabled at boot by `configure.sh`

Posts tagged "tech"

Meet Jotley - Building a Native Apple Notes App with AI Transcription

Project NVIDIA JetBot (Orin Nano)