Grant Isom

Bringing ListWithMe Back to Life

Tue, 24 Feb 2026 00:00:00 +0000

Back in 2019, I built ListWithMe—a simple iMessage app for creating shared shopping lists. My wife and I used it constantly for grocery runs and weekend errands. It was nothing fancy, but it solved a real problem: quickly creating a list that both of us could see and edit in real-time, right inside our conversation.

Then life happened. The app sat untouched as iOS evolved, and eventually Apple removed it from the App Store. I always meant to update it, but between work and other projects, it kept getting pushed to “someday.”

Well, someday finally arrived.

A Complete Rebuild

Rather than patch the old UIKit codebase, I decided to rebuild ListWithMe from scratch using SwiftUI. The original app was functional but minimal—just lists and items. The new version keeps that simplicity while adding features I’ve wanted for years:

Smart Input — Type “3 apples” or “milk x2” and the app automatically parses the quantity. It sounds small, but it makes adding items so much faster.

Priorities & Due Dates — Not everything on a shopping list is equal. Now you can mark items as high priority or set a due date for time-sensitive errands.

Categories — Group items by aisle or type. When you’re navigating a store, having items organized by Produce, Dairy, and Frozen makes the trip faster.

Activity Feed — See who added or completed items. When you’re shopping together but apart, it’s helpful to know what your partner just grabbed.

Batch Actions — Select multiple items to complete or delete at once. Clear all completed items with a single tap.

Search & Sort — Find items quickly in long lists. Sort by name, category, priority, due date, or drag to reorder manually.

The Technical Side

The rebuild gave me a chance to work with some iOS technologies I hadn’t used in personal projects:

SwiftUI with the new @Observable macro (iOS 17+)
Core Data with CloudKit sync for seamless multi-device support
Modern Swift patterns and concurrency

The codebase is open source on GitHub if you want to poke around. It’s a good example of a relatively simple but complete SwiftUI app with persistence.

Why iMessage Apps Still Matter

When I first released ListWithMe, the biggest complaint was discoverability. Users would download it, then struggle to find where it went—because iMessage apps don’t appear on your home screen. That’s still true today, and it’s still the biggest friction point.

But I think there’s something valuable about apps that live inside your conversations. You don’t need to context-switch. You don’t need to share links or coordinate which app to use. If you’re already texting someone, the list is right there.

For my wife and me, it’s become invisible infrastructure. We don’t think about it—we just have a shared list that updates as we shop.

What’s Next

ListWithMe 2.0 is available now on the App Store. I’m planning to keep iterating based on feedback. A few things I’m considering:

Recurring lists (weekly grocery templates)
Siri integration
Widgets for quick access

If you try it out, I’d love to hear what you think. You can find me on GitHub.

Here’s to shared lists and fewer forgotten items.

HealthQL Now Supports React Native

Sat, 07 Feb 2026 20:00:00 +0000

HealthQL v1.1.0 adds full React Native and Expo support. You can now query Apple HealthKit using the same SQL syntax from JavaScript/TypeScript apps.

GitHub

Documentation

npm

Quick Example

import { HealthQL } from 'react-native-healthql';

// Request authorization
await HealthQL.requestAuthorization({
  read: ['heart_rate', 'steps', 'sleep_analysis'],
});

// Query with SQL
const results = await HealthQL.query(`
  SELECT avg(value) FROM heart_rate
  WHERE date > today() - 7d
  GROUP BY day
`);

Same SQL syntax as the Swift version—the React Native package wraps the native Swift implementation, so you get real HealthKit queries, not mock data.

Installation

npm install react-native-healthql

Add the Expo config plugin to your app.json:

{
  "expo": {
    "plugins": [
      ["react-native-healthql", {
        "healthShareUsageDescription": "Read health data to display insights"
      }]
    ]
  }
}

Then rebuild:

npx expo prebuild --clean
npx expo run:ios

What’s Included

Full TypeScript types
All 18 quantity types (heart rate, steps, calories, etc.)
Category types (sleep analysis, headache, fatigue)
Workouts and sleep sessions
Schema introspection for building dynamic UIs
Structured error handling with suggestions

Also New: CocoaPods Support

The Swift library is now available via CocoaPods in addition to SPM:

pod 'HealthQL', '~> 1.1.0'

Platform Support

iOS only for now. Android throws a clear PLATFORM_NOT_SUPPORTED error—Health Connect support is on the roadmap.

Check the React Native docs for the full API reference.

HealthQL: SQL for Apple HealthKit

Sun, 01 Feb 2026 20:00:00 +0000

I built a Swift library that lets you query HealthKit data using SQL syntax. Working with HealthKit directly involves a lot of boilerplate—callback-based APIs, type-specific query objects, manual result transformation. HealthQL simplifies this into something more familiar.

GitHub

Documentation

Quick Example

SELECT avg(value), min(value), max(value)
FROM heart_rate
WHERE date > today() - 7d
GROUP BY day

This returns daily heart rate stats for the past week. The library handles all the HealthKit query setup, permissions, and result formatting.

Swift DSL

If you prefer type-safety, there’s also a Swift DSL:

let result = try await Health
    .select(.heartRate, aggregates: [.avg, .min, .max])
    .where(.date, .greaterThan, .date(.daysAgo(7)))
    .groupBy(.day)
    .execute()

Both approaches compile down to the same intermediate representation before hitting HealthKit.

Supported Data

The library covers most common health types—steps, heart rate, calories, workouts, sleep sessions, and more. It supports aggregations, grouping by time periods, and the standard comparison operators you’d expect.

Installation

Add it via Swift Package Manager:

https://github.com/glisom/HealthQL.git

The documentation site has the full syntax reference and more examples. Feel free to open an issue if you run into any problems or have suggestions.

Accessibility Testing in Maestro

Wed, 19 Jul 2023 15:33:47 +0000

Recently, our mobile team came across a problem with text sizing in our app when customers had the “Larger Accessibility Sizes” Display Text option on. After updating our app to more fully support dynamic text, we came across a cool solution to automate testing this for future releases.

Using Maestro UI Testing, we could enable these settings for certain tests. We created actions within our flows to enable certain settings prior to running the actual UI tests steps. This pattern can be applied on both Android or iOS as Maestro gives you full access to the simulator even running in their cloud environment. If you have not checked out Maestro for UI testing on either React Native or Native applications, I would highly recommend it, as it solves so many historical issues with similar tools.

Below is an example enabling the “Larger Accessibility Sizes” and then launching the target application in an iOS Simulator.

Example Maestro Flow

appId: <your_bundle_id>
---
- tapOn:
	id: "Settings"
- tapOn:
	id: "ACCESSIBILITY"
- tapOn:
	id: "DISPLAY_AND_TEXT"
- tapOn:
	id: "LARGER_TEXT"
- tapOn: text: "Larger Accessibility Sizes"
	index: 0
- tapOn:
	point: "50%,90%"
- pressKey: "Home"
- launchApp:
	appId: "<your_bundle_id>"

This pattern or strategy can be applied to any of the accessibility settings available on simulators/emulators. This can be a huge help to ensure new UI updates and features are accessible while continuing to release fast.

Using Act to Run Github Actions Locally

Mon, 15 May 2023 22:06:58 +0000

https://github.com/nektos/act

The Act package offers a convenient way to execute your GitHub Action workflows locally. It’s a valuable tool when debugging or working on issues that either have a long runtime or are complex, saving you those precious minutes.

Installation

The installation process is quite straightforward. First, ensure Docker Desktop is installed on your computer. Then, for Mac/Linux users, the easiest installation method is via Homebrew.

brew install act

That’s all there is to it! Upon executing your workflows for the first time, the required Docker containers should automatically download.

Setup

An essential point to remember is to pass in your personal access token from GitHub when running any workflow dependent on SECRETS or environment variables.

Executing Workflows

With everything set up, running workflows becomes a breeze:

➜ act pull_request --container-architecture linux/amd64

Checkout the README for additional examples and a comprehensive breakdown of all the capabilities this package offers. I believe Act is an indispensable tool for anyone working with GitHub Actions who wants to test or debug their changes swiftly.

Expo App Config Setup for Multiple Environments

Wed, 01 Feb 2023 04:22:25 +0000

Expo is a free and open-source platform for creating and building mobile apps using JavaScript and React Native. It is a popular choice among developers for its ease of use and its ability to quickly set up and run a mobile app without the need for extensive configuration. Expo provides a set of tools and services that allow developers to build, test, and publish their apps to the App Store and Google Play with minimal setup and without the need for Xcode or Android Studio.

One of the most powerful features of Expo is the ability to use a single codebase to create apps for both iOS and Android platforms, which can save a lot of time and effort. Expo also provides a rich set of pre-built components and APIs for common functionality such as push notifications, camera access, and location tracking, which can help developers get their apps up and running quickly.

One of the things you may come across is figuring out how to setup different environments or app variants within an Expo app. If you want to just target one binary on iOS and Android, there is very little to do other than setup some environment variables. If you want to have multiple apps for development, QA/test, production, etc then you’ll need to do a few things to be able to take advantage of all Expo has to offer without having to manage these things yourself.

Converting to app.json to app.config.js for multiple environments.

The first step is to convert the app.json file into an app.config.js file. This allows for dynamic changes for things such as your app’s bundle identifier/package name. Below is an example of a basic conversion. Somethings to note is that you are not able to auto bump build numbers when using the app.config.js but there are other ways to accomplish this.

app.config.js

function getBundleId() {
    switch (process.env.APP_VARIANT) {
        case 'development': {
            return 'com.isom.grant.dev';
        }
        case 'qa': {
            return 'com.isom.grant.qa';
        }
        case 'production': {
            return 'com.isom.grant.prod';
        }
        default: {
            return 'com.isom.grant.dev';
        }
    }
}

export default {
    name: getName(),
    ...
    ios: {
        bundleIdentifier: getBundleId(),
        ...
    },
    android: {
        package: getBundleId(),
        ...
    },
    extra: {
        APP_VARIANT: process.env.APP_VARIANT || 'development',
    },
};

eas.json

{
    "build": {
        "development": {
            "distribution": "internal",
            "developmentClient": true,
            "autoIncrement": false,
            "env": {
                "APP_VARIANT": "development"
            },
            "android": {
                "buildType": "apk"
            }
        },
        ...
    },
    ...
}

Now simply providing the --profile when running an eas build command will set the bundle identifier and package name of your app. You can do this for environment variables as well.

Constants.expoConfig?.extra?.APP_VARIANT

The above snippet will return the value set during build at runtime.

Passing Environment Variables to EAS Update

Environment variables are fairly straightforward for updates. You will need to configure use interactive mode to attach branches to variants. But after that, you will just include the environment variable(s) before the command like any other CLI.

APP_VARIANT='production' eas update -p all --branch prod

To wrap things up, if you’re using Expo to build your mobile app, setting up multiple environments or variants can be a big help. By converting your app.json file to a app.config.js file, you’ll have more control over your app’s settings and can utilize environment variables for native pieces. And if you need to pass on environment variables to the EAS update, it’s pretty simple. Just include the variables before you run the update command and you’re good to go. All in all, Expo makes it easy for you to build, test, and publish your app to both the App Store and Google Play with a smooth and stress-free experience.

Notion 101 for Software Engineers

Sat, 14 Jan 2023 20:28:58 +0000

As a software engineer, staying organized and on top of your projects can be a challenge. Not only are there many projects going on at times, but how your work is managed can be split between tools. We use Jira, Confluence, and Github at work, I use Todoist to deal with personal tasks and projects, and then Notion sits in between all of those helping to bring the information needed to the front. In this blog post, I will walk through how I use Notion as a software engineer to keep my work running smoothly and streamline how I capture interesting or important information.

The Work Log

Keeping a Daily/Weekly Work Log is a great way to document what you worked on during the day and any questions you want to bring up at Standup the next morning. This can be done in any note-taking tool, but I find that Notion is particularly useful for this purpose. I have a daily template set up that I use to log my work and any questions I may have. This template includes sections for:

Tasks completed
Problems encountered
Questions for the team
Things to follow up on

This has been incredibly helpful in keeping my update concise and to the point while not forgetting something I need help with. The work log has also served as a great utility when trying to track down something I worked on that is not easily found in Jira or Github. I highly recommend every engineer at least try keeping a log for a couple months and see if they get a benefit from it.

Templates

One of the most powerful features of Notion is its ability to create custom templates. These templates can be used for everything from meeting notes to planning sprints, and they can be easily shared with other members of your team. These allow you to spend less time setting things up and more time capturing the important information needed during meetings. For example, I have a template set up for meeting notes that includes sections for:

Agenda
Attendees
Discussions
Action items
Follow-up

This has been extremely helpful in keeping track of what was discussed during meetings and what the next steps are. I also have a template for capturing my achievements and work during the year. This way when it comes time for reviews I have a breakdown of all of the things I was proud of throughout the year. This can be very helpful at companies of all sizes and makes your manager’s life easier when understanding your impact. There are endless ways templates can be used, but I think this is a major reason to use Notion or a similar tool over something like Apple Notes.

Web Clipper

The Notion Web Clipper has fully replaced Instapaper or Chrome/Safari Reading Lists for me. It allows me to capture helpful articles, links, even things like README’s from Github. It works on pretty much any browser and mobile and is an easy way to quickly capture web pages that you want to reference later. It also tries to pull the text into a page so you can search over the content of all of your saved links. The Web Clipper is an extremely helpful tool when you are starting a new project as well since you can gather a massive amount of information and references very quickly without having to keep a million tabs open.

Teamspaces and Notion AI

Notion’s recent release of team spaces and Notion AI has made it an even more versatile tool for software engineers. Team spaces allows for easy collaboration and sharing of templates, databases and pages within a team, making it a great tool for managing projects and tasks together. Notion AI, on the other hand, offers a range of features to help you with your workflow such as automated reminders, scheduling, and natural language processing to quickly find information. These features have the potential to greatly improve productivity and collaboration within teams. Additionally, with a growing community and tons of resources online to maximize Notion’s potential, it is an extremely versatile tool that can help software engineers stay organized and get work done faster.

9 Must-Read Books for Software Engineers in 2023

Mon, 02 Jan 2023 23:43:56 +0000

As a software engineer, staying up-to-date with the latest developments and best practices is essential for growth. One of my favorite (and what I feel is overlooked) methods for growth is reading books. We spend a large part of our day reading Stack Overflow and blog posts, but books have really helped me see things in a different light or understand something I do not come across on a daily basis.

In 2022, I read a number of books that were extremely valuable to my career as a software engineer. Here are nine that I highly recommend for software engineers at all stages of their careers to consider adding to their reading lists for 2023:

“Build: An Unorthodox Guide to Making Things Worth Making” by Tony Fadell is a must-read for anyone looking to create things that matter. Fadell shares his unique perspective on how to focus on small, achievable goals and pivot when necessary.

“The Phoenix Project: A Novel about IT, DevOps, and Helping Your Business Win” by Gene Kim, Kevin Behr, and George Spafford is a captivating story about an IT manager who must turn around a failing project. Along the way, he learns about the principles of DevOps and how to apply them to his work.

“The Hard Thing About Hard Things: Building a Business When There Are No Easy Answers” by Ben Horowitz offers candid and practical advice on the challenges of entrepreneurship. Horowitz covers topics such as hiring, firing, and managing through tough times, and provides valuable insights on how to navigate the ups and downs of building a business.

“Structure and Interpretation of Computer Programs,” also known as the “Wizard Book,” is a classic text that covers the fundamental concepts of computer science and programming using the Lisp language. This book is a must-read for any serious software engineer.

“A Philosophy of Software Design” by John Ousterhout argues that good software design is all about simplicity and clarity. He offers practical advice on how to achieve these qualities in your own code. This is a good one to read even on a yearly basis.

“The Pragmatic Programmer: From Journeyman to Master” by Andrew Hunt and David Thomas is a comprehensive guide to becoming a better software engineer. It covers a wide range of topics, including debugging, testing, and refactoring, and is filled with useful tips and techniques. Make sure to pick up the 20th anniversary edition.

“An Elegant Puzzle: Systems of Engineering Management” by Will Larson discusses the challenges and opportunities of managing software development teams. Larson covers topics such as building effective processes, setting goals, and creating a positive culture.

“Software Engineering at Google: Lessons Learned from Programming Over Time” by Titus Winters, Tom Manshreck, and Hyrum Wright offers a behind-the-scenes look at how Google approaches software development. It covers topics such as code review, testing, and technical debt, and provides valuable insights into how to build reliable and scalable systems.

“INSPIRED: How to Create Tech Products Customers Love” by Marty Cagan is a must-read for anyone looking to create successful tech products. Cagan covers topics such as defining the product vision, building a strong team, and gathering customer feedback, and provides practical advice on how to apply these principles to your own work. Commonly recommended for product managers, I think its a great read for engineers as well as it will help when working cross-functionally with your product team.

These books provided invaluable insights and kept me motivated and inspired throughout the year. “An Elegant Puzzle” was particularly helpful in figuring out how to more effectively handle support issues within my team, while “Software Engineering at Google” offered valuable guidance as we were setting up a new project and repository. I hope this list of recommendations will provide some useful reading options for you in 2023 as you continue to grow and develop in your software engineering career.

2 Years at Illuminate, A Retrospective

Mon, 07 Nov 2022 23:51:06 +0000

As I move on to the next chapter in my career, I wanted to reflect on the past two years at Illuminate. Here are the lessons learned from moving to a 20 person startup from a 26k person company.

TL;DR

Things move fast.
You can make an immediate impact on the organization.
Your architecture will reflect your organization.
Managing is more than 1 on 1’s.
Culture matters even more than at a larger organization.
Healthcare software is challenging, the data is not uniform, but is some of the most rewarding work.

Things move fast.

Coming from a larger company, I was used to quarterly planning, long release cycles, and processes for just about everything. One of my favorite things about going to a startup was how quickly we moved. The only processes that existed were for compliance and to ensure high quality with our changes. If you have an idea, or want try something you are empowered to do it!

Impact

Being at a startup, you can have a tremendous amount of impact and responsibility. It can be a great opportunity to take a chance or risk but can also create silo’s of critical information. During my second year, we decided to try a new approach and have engineers focus on a general area of architecture instead of a product and also participate in a support rotation. With the level of tech debt we were facing, this was an extremely painful switch. Three months in we noticed our team had quickly destroyed most of these silo’s and documented some of our unknowns. One of my coworkers during this time, started writing down everything he came across during his support rotation and how to reproduce or fix the issues. He not only fixed a lot of the issues but he created a shared space that included all the details. As time went on, the rest of the team followed suite and this became one of the greatest changes our team made. He didn’t tell anyone else to do it, just showed everyone and the team immediately bought it. The time spent on support decreased by almost half due to this. I just think that is a great example of how even little things can make a big difference, and when the team is only 8 people, you really feel it.

Organizational Architecture

One of the things I was excited to be involved in was helping relayout our company’s org chart to be closer to how we did business. From an engineering perspective, there were three things I thought really made an impact:

We made engineering flatter and less specific, aka SWE’s and SRE’s shared responsibilities and worked closer together.
Support was incorporated into the entire engineering team versus being something dealt with by client services.
We created processes that captured data and work being done so we could make objective decisions versus relying on people’s experiences purely.

This ended up showing us some of our biggest pain points and we were able to rapidly adjust.

The next thing we spent a lot of time trying to figure out was how to have client services interact with the engineering team. This led to building out tools and processes that let each organization be more independent from each other. We integrated our work tracking tools like Monday and Jira, and we identified things engineering could pass off to client services to speed up client onboarding. When I first started, client services was at the whim of engineering which meant these tasks like onboarding or transforming data was always held up by engineering. While I am sure this is still ongoing today, we made massive improvements that really helped our teams work together instead of bottleneck each other.

Managing a Team

Illuminate was my first chance to really manage an entire team. At my previous company, I managed a team of 5 engineers in an organization of 200. This was a wildly different experience. Three hard learning lessons:

Strong individual contributors do not always make strong managers.

While I believe it can be dangerous to move too slow promoting or recognizing a strong team member, it can be worse to put them in a position they cannot continue to succeed in. Annual review cycles work and prevent a lot of political issues within an organization. There are also times where it makes sense to move someone into a new role outside of cycles, but those should be something done as infrequently as possible.

Your direct reports should always have a good understanding of how they are performing, aka they should not be caught off guard with good or bad news.

Communication and regular 1 on 1’s are not for you to talk about work, they are there to let your direct report talk with you about anything on their mind and for you to communicate anything about their personal growth within the organization. If you have to let someone go or put them on a performance plan, they should be aware that it was coming. Being caught off guard is not a fun situation for your direct report and will probably lead to a poor professional relationship with them.

Watch out for legends of the old guard or team members talking about things that “just work” or “don’t want to mess with”.

I really got kicked in the butt when I realized all the stories about previous engineering teams doing miracle work or having to do something extraordinary was just a cover up for tech debt. Nothing is worse than getting a call from a client about a piece of your tech stack that you do not have strong visibility over.

The biggest takeaway I have is that, as a manager, you are there to help your direct reports succeed and provide a buffer from things that prevent them from being able to do great work. You can’t be everyone’s friend but you also need to recognize that you are there to help them first and foremost.

Culture

If there was only one thing I could take away from this last experience, it would be how important a good work culture is. Especially in a fast paced environment, I realized the health of the team is dependent on making sure work is somewhere where everyone feels supported and can be themselves. When things start getting challenging or an emergency happens, it seemed like these are the things that make the biggest difference. Going forward, will be one of the main things I look for in a company. It cannot be an after thought, it needs to be a priority. I don’t mean free food and ping pong tables or extra days off, but a place that supports their staff in the work they do and understands employees have lives outside of work.

Healthcare Software

Healthcare software and data is a mess. Nothing is uniform due to the emergence and integration of electronic medical records over the last 40 years. There are some exciting companies and projects tackling those problems around data uniformity and cross organization data sharing, but while I was at Illuminate, it was both fun and challenging working on the data ingestion pipelines across our client base. While everything is generally similar, no two hospitals are the same which led us down some interesting paths around solving this problem at scale. The other interesting thing about AI or machine learning in healthcare is the amount of insights or data points generated versus how many are actually acted on. One of the biggest things I learned was that follow-up, or helping the hospitals track patients related to some insight is one of the biggest holes in the digital space right now. I am excited to see where the team goes the next couple of years working on these problems.

In Conclusion

I had a great two years at Illuminate and will miss working with the engineering team. It was my first time getting to lead a team of that size and learned a lot in the process. Looking forward, I feel like the experience prepared me for what is to come in my next couple chapters.

Next Chapter

Mon, 28 Sep 2020 00:00:00 +0000

Starting back in July, I made the next move in my personal career. After meeting with one of my good friends, Alek, I decided to follow him to another Kansas City company, Illuminate.

The one thing I had to really think about was stepping away from the app development world for a while. It has been a great space to start my career and is what got me into software from the beginning. But I would be doing myself a disservice staying so narrowly focused in one development ecosystem or frame. At Illuminate I have been working mainly on a “MLOps” application for creating datasets for training models over. It allows our clinical experts to label radiology notes and documents efficiently, while also being a broad enough solution for any other similar data grouping.

I have really enjoyed going to a smaller startup so far, our team moves fast, everyone gets along, and we have tons of really exciting opportunities in front of us as a company!

I also think the change of technology stacks will lead to some interesting topics to talk about on here. Stay tuned!