I wanted to have a photographic timeline of my life and create memory compilations. The best solution I could think of is using Apple iOS Photos.

The Problem

I appreciate Apple’s approach to privacy, the majority of computation is done on-device. That includes Apple Photos Intelligence features. My goal is to create a photographic timeline of my life, and have it processed on-device. I don’t want to use iCloud for a couple of reasons:

• My library is too large for my current iCloud plan (30 years of photos and videos) and it barely fits in my current iPhone (256GB)

• I’m eliminating subscriptions where possible

• I want to have full control over syncing (e.g., impossible with iCloud Photos as it syncs everything in the library)

• I want to manage my library independently of any single machine

Since the iPhone 4 era, I’ve synced photos via iTunes/Finder. This method still works, but photos synced this way don’t work with Apple Intelligence features. They end up in a separate internal directory that isn’t available for Apple Intelligence to process; this means no Memories, no intelligent search, no automatic organization.

Disclaimer: This is a manual process with no automation or magical solutions. I’m sharing it primarily to document what doesn’t work and why. If you have a better solution that meets these requirements, I’d love to hear about it!

What doesn’t work

• Syncing via Finder from a folder

• Syncing from Photos.app without iCloud

• Third-party sync tools (none found from my research)

In all cases, synced photos, end up in a separate internal iOS directory that is not available to Apple’s Photos Features.

Only AirDrop (and direct import via iOS Files app) places photos in the correct directory for full Apple Intelligence functionality.

AirDrop Workflow

Organize your source library

Create a main directory to store copies of all the photos you want on your iPhone. Inside the main directory, photos should be organized by year; I find this makes sorting and tracking transfers easier.

Prepare your photos

• Convert to JPEG/HEIC format. I keep RAW files in a separate archive, off-device

• Ensure that exported or edited photos have the right creation time, otherwise they will appear in the wrong place in your photos library. Some apps overwrite creation dates when exporting. I’ll show how to fix that below.

Airdrop

To my experience batches of around 400 photos are the most reliable transfers. Larger batches might fail.

Worth a try: there are reports for wired AirDrops which can be faster than wireless. For me, it didn’t seem to work, and also I couldn’t find any official Apple documentation.

Tip: Some users report faster transfers with wired AirDrop (iPhone connected via cable), though I haven’t noticed a difference and Apple doesn’t officially document this feature.

Once transferred, your photos will appear in the native Photos app with full access to Memories, intelligent search, and all other Apple Intelligence features.

That’s it.

Alternative: External Drive

Instead of AirDrop, you can connect an external drive containing your main folder directly to your iPhone and import photos through the Files app. However, I prefer to do it over AirDrop as I find it easier to manage files in MacOS.

A perk that comes with self-managing your library is that both solutions work interchangeably; you can AirDrop and you can import via a drive when traveling.

Backup of your main

Your main folder serves as your backup. You can consider additional backups using standard tools like Time Machine or rsync.

Backing Up Photos From Your iPhone

One trade-off with this approach is that backing up photos shot on your phone can become more complicated.

I’ve always used Image Capture to back up iPhone photos. The problem is that AirDropped photos now live in your native iPhone library alongside photos you actually took with your device. The Download All button in Image Capture no longer works cleanly as it would download everything, including photos you already have in your main folder. Duplicates will become a thing.

Image Capture shows Maker and Model fields but doesn’t let you filter by them, so you can’t easily isolate iPhone camera photos from AirDropped content from other sources.

Workarounds

If you back up regularly, you can sort by date in Image Capture and select only recent photos. This works well for if you’re consistent with your backup schedules.

Otherwise, you can AirDrop back to your Mac. This lets you filter in the iOS photos app by device, date, or any other metadata.

This solution is far from friction-less, but it works. If you want full control over your photo library with complete Apple Intelligence features and no iCloud dependency, manually syncing with AirDrop is currently the only viable option.

Tools & Scripts

Here are scripts and commands I use for this workflow. Adapt them to your needs. I prefer a programmatic approach over GUI tools mainly for speed.

Important: Always work on copies of your photos in a separate directory. Place the script in that directory and run it.

Prerequisites: Basic familiarity with Terminal and running shell scripts. If you’re new to this, consider using GUI apps.

Transcoding

I have a large number of photos in lossless formats (e.g., TIF). I want to compress them to JPEG or HEIC and preserve their creation dates so they appear in the correct order in my timeline.

#!/bin/bash

# Convert images and preserve original creation dates
# Usage: ./convert-and-preserve-dates.sh <INPUT_FORMAT> [OUTPUT_FORMAT]
# Examples: 
#   ./convert-and-preserve-dates.sh TIF           (converts to JPEG)
#   ./convert-and-preserve-dates.sh TIF heic      (converts to HEIC)
#   ./convert-and-preserve-dates.sh PNG jpg       (converts to JPEG)

if [ $# -eq 0 ]; then
    echo “Error: No input format specified”
    echo “Usage: $0 <INPUT_FORMAT> [OUTPUT_FORMAT]”
    echo “Examples:”
    echo “  $0 TIF           (converts to JPEG by default)”
    echo “  $0 TIF heic      (converts to HEIC)”
    echo “  $0 PNG jpg       (converts to JPEG)”
    exit 1
fi

INPUT_FORMAT=”$1”
OUTPUT_FORMAT=”${2:-jpg}”  # Default to jpg if not specified

# Check if ImageMagick is installed
if ! command -v magick &> /dev/null; then
    echo “Error: ImageMagick is not installed”
    echo “Install it with: brew install imagemagick”
    exit 1
fi

# Check if any files with the specified format exist
if ! ls *.”$INPUT_FORMAT” 1> /dev/null 2>&1; then
    echo “Error: No .$INPUT_FORMAT files found in current directory”
    exit 1
fi

echo “Converting *.$INPUT_FORMAT to $OUTPUT_FORMAT...”
magick mogrify -format “$OUTPUT_FORMAT” *.”$INPUT_FORMAT”

echo “Preserving original dates...”
for f in *.”$INPUT_FORMAT”; do
  original_date=$(stat -f %Sm -t “%Y%m%d%H%M.%S” “$f”)
  converted_file=”${f%.$INPUT_FORMAT}.$OUTPUT_FORMAT”
  
  if [ -f “$converted_file” ]; then
    touch -t “$original_date” “$converted_file”
    echo “  ✓ ${converted_file}”
  else
    echo “  ✗ Failed to convert: $f”
  fi
done

echo “Done! Converted $(ls -1 *.$OUTPUT_FORMAT 2>/dev/null | wc -l | xargs) files to $OUTPUT_FORMAT.”

Setting Dates

I have scanned film photos where I know the shooting date (encoded in filenames or recalled from memory by comparing with iPhone photos from that timeSetting exact timestamps is unrealistic, but at least having the correct date is important for timeline ordering. This script sets dates for JPEG files.

#!/bin/bash

# Usage: ./set_creation_date.sh DD-MM-YYYY

input_date=$1
if [[ -z “$input_date” ]]; then
  echo “Usage: $0 DD-MM-YYYY”
  exit 1
fi

# Convert DD-MM-YYYY to MM/DD/YYYY (SetFile format)
day=${input_date:0:2}
month=${input_date:3:2}
year=${input_date:6:4}
formatted_date=”$month/$day/$year 00:00:00”

# Iterate over jpeg files in current directory
for file in *.jpg *.jpeg *.JPG *.JPEG; do
  if [ -f “$file” ]; then
    echo “Setting creation date of $file to $formatted_date”
    SetFile -d “$formatted_date” “$file”
  fi
done

Tip: You can adjust metadata (date, location) directly in the iOS Photos app. Tap a photo → swipe up → tap “Adjust” next to the date or location.

Preserving Dates for Edited Videos

I have large videos, and I keep some parts for my timeline. When I export the edited video from DaVinci Resolve, or any other editor, the creation date reflects the date of the export. To maintain timeline ordering I copy the creation date of the original video to the exported one.

touch -r /path/to/original/video.MP4 /path/to/exported/video.mp4

These scripts are suggestions for your workflow, mainly to inspire what you can do with CLI tools to work more efficiently.

Flattening Directories

Recursively finds all files (not directories) located at least two levels deep within the source directory and then moves each of those files into the destination directory.

find /path/to/source -mindepth 2 -type f -exec mv -i '{}' /path/to/destination \;

Final Thoughts

It’s certainly easier to do this via a cloud service. But if you value control, privacy and freedom from subscriptions, AirDrop is currently the only option for accessing Apple Intelligence features in Photos without iCloud.

I hope Apple eventually adds proper local sync to Finder that works with on-device processing. Until then, this is the workaround.

I’ll update this post as I refine my workflow. If you find something better, let me know.

TL;DR

• Architecture guides energy towards useful outcomes

• We reach autonomy when our work is aligned with our values

• Generalists are amplified with AI

• One diagram, one message

• Story estimates are guesses — don’t count on them. Count on feedback

• Know yourself to serve better

• Leadership: contribute, influence, take responsibility, be available

• Architecture supports agility

• Architecture is a living set of decisions

Architecture guides energy towards useful outcomes

Architecture limits the number of possible interactions. It defines the boundaries for self-organization.

In social systems, individual goals increase self-organization and shared goals reduce it.

Think of people in a train station, each moving independently (self-organized) towards their own destination. Once they converge on a platform (a shared destination) structure emerges.

The same applies to teams and systems. Self-organization is always there. Architectures guides energy towards useful outcomes.

We reach autonomy when our work is aligned with our values

Achieving autonomy, depends on enabling constraints. These are boundaries that limit freedom yet provide a structure that enables function.

For example, teams own their stack end-to-end (autonomy) and follow architectural principles (constraint). This lets them move faster and make better decisions.

Generalists are amplified with AI

• M-shaped people, those with multi-domain skills, can move ideas between boundaries.

• Human touch and attention are scarce; AI attention is better than nothing.

• There’s magic in learning new skills, but automation has made us complacent. It’s a fine line between preserving human expertise and delivering value through automation.

One diagram, one message

Diagrams are like writing, they should serve a purpose and know their audience.

• Different audiences need different diagrams.

• Don’t mix levels of abstraction, it causes confusion. One diagram, one message.

• Use color with care; 4.5% of the world population has color deficiency.

• Sequence diagrams should be simple; code changes frequently. Focus on actions, not functions.

• Always provide context!

Story estimates are guesses — don’t count on them, count on feedback

Estimates are often required but they are guesses. What matters more is steering. If something can be worked on, deployed, and used then it can produce feedback. And feedback is how we steer, with feedback we can decide.

Know yourself to serve better

• Take time to reflect alone. Look inside and view yourself from the outside. That’s how you stay useful to others.

• Do retros consistently. It’s all about us reflecting together.

• Reduce distractions, cause we all pay with attention!

frameworks / templates

Leadership: contribute, influence, take responsibility, be available

Autonomous teams are shaped by culture, structure, and people who step forward.

• Being a good technical leader means stepping forward: contribute, influence, take responsibility, be available.

• Speaking the languages of people is something we were not taught in university — we learned the languages of computers. Tech leadership means bridging the gap between humans and machines.

• Juniors matter! They keep the pipeline going. They aren’t yet “damaged” by work and can ask questions from a fresh perspective.

• Leadership is a skill that can be trained and must be practiced. Being a great technical leader implies taking risks when making decisions.

Architecture supports agility

Agility is about adapting quickly and delivering value continuously. Adaptation needs structure, and that’s where architecture becomes relevant.

• If you’re the most experienced person on the team, help grow your teammates. A system is too large for one mind, it’s built, understood, and expanded by the team. Each member holds a part; together, they understand the whole.

• Architecture is iterative, it evolves and expands.

Slides

Architecture is a living set of decisions

• Leaders can influence without direct power. Take away a CEO’s power, are they still influential? If so, they’re a true leader. Leadership doesn’t require authority.

• Tech debt becomes apparent when it prevents progress.

🫰🏼