Podcast App Boilerplate for iOS

Audio playback and the background-mode work a podcast app can't skip

A podcast app is an audio app, and iOS audio has non-negotiable requirements the moment a user locks their phone. Playback has to continue in the background, the lock screen and Control Center have to show the episode and respond to play, pause, and skip, and the audio session has to be configured so your app cooperates with other audio. The Swift Kit does not ship a proprietary player that hides AVFoundation from you — that would fight you the moment you need custom behavior. Instead it gives you a clean SwiftUI architecture where an AVPlayer-based player model lives naturally, plus the account and sync layer that playback progress writes to. You enable the Audio background mode in your target's capabilities, set the audio session category to playback, and the player keeps running when the screen is off.

import AVFoundation
import Observation

@Observable
final class AudioPlayer {
    private var player: AVPlayer?

    func configureSession() {
        let session = AVAudioSession.sharedInstance()
        // .playback keeps audio going when the screen locks;
        // .spokenAudio tunes behavior for talk content.
        try? session.setCategory(.playback, mode: .spokenAudio)
        try? session.setActive(true)
    }

    func play(episodeURL: URL) {
        player = AVPlayer(url: episodeURL)
        player?.play()
    }

    func pause() { player?.pause() }
}
// Also enable the "Audio, AirPlay, and Picture in Picture"
// background mode in Signing & Capabilities.

Lock-screen controls and Now Playing info

Once audio plays in the background, users expect to control it without opening the app — from the lock screen, Control Center, AirPods, and CarPlay. That is MPRemoteCommandCenter and MPNowPlayingInfoCenter, both native and free. The Swift Kit does not wrap these behind a custom abstraction, because they are the kind of platform surface you want direct control over; it gives you an architecture where the player model that owns your AVPlayer is the obvious place to register remote commands and publish the current episode's title, artwork, and elapsed time. This is podcast-specific glue you write once, and the kit keeps it out of your view layer where it belongs.

import MediaPlayer

extension AudioPlayer {
    func setupRemoteCommands() {
        let center = MPRemoteCommandCenter.shared()
        center.playCommand.addTarget { [weak self] _ in
            self?.player?.play(); return .success
        }
        center.pauseCommand.addTarget { [weak self] _ in
            self?.player?.pause(); return .success
        }
        center.skipForwardCommand.preferredIntervals = [30]
    }

    func updateNowPlaying(title: String, elapsed: TimeInterval) {
        var info = [String: Any]()
        info[MPMediaItemPropertyTitle] = title
        info[MPNowPlayingInfoPropertyElapsedPlaybackTime] = elapsed
        MPNowPlayingInfoCenter.default().nowPlayingInfo = info
    }
}

Downloads, offline listening, and progress that syncs

Podcast listeners download episodes to listen on a commute, a flight, or a run with no signal — offline listening is core, not optional. The kit gives you the foundation to build it honestly. You download episode files with URLSession's background download support so a transfer finishes even if the app is suspended, store them in the app's file system, and record which episodes are downloaded and how far the user got in Supabase Postgres. Because playback progress lives on the account, a user can start an episode on their phone and resume it on their iPad. The kit's centralized data layer is where that download index and progress state live cleanly.

• Use URLSession background downloads so episode transfers complete when the app is suspended
• Store downloaded audio in the app's file system, indexed in Supabase Postgres
• Playback progress on the account so a user resumes across iPhone and iPad
• Supabase storage for show artwork and any user-generated audio or clips

Subscriptions, premium feeds, and reminders

Podcast apps monetize with a premium tier — ad-free listening, exclusive shows, or early access. The Swift Kit ships RevenueCat with a configurable paywall and multi-tier entitlements, so you can gate a premium feed behind a subscription and let free users hear the standard catalog. Sign in with Apple and email auth anchor a listener's subscriptions and history to a real account. Push notifications — included in the kit — are how a podcast app drives retention: a new episode of a followed show just dropped. Analytics show which shows get listened to and where the paywall converts, and onboarding gets a new listener from install to their first play with minimal friction.

• RevenueCat paywall for ad-free, exclusive, or early-access premium tiers
• Sign in with Apple + email so followed shows and history follow the listener
• Push notifications for new episodes of followed shows
• Analytics on listens and paywall conversion, plus an onboarding flow

What you build on top

The Swift Kit is not a finished podcast app. There is no bundled podcast directory, no RSS feed parser, no proprietary audio engine. That is the point — your show catalog, your feed ingestion, and your playback experience are your product. You bring the RSS or API parsing that turns a feed into episodes, the player behavior on top of AVFoundation, and the download management. The kit removes the roughly 30% of any audio app that is identical everywhere: accounts, subscription sync, storage, paywall, push, onboarding, analytics, and a design system that rethemes from one file. What it adds on top of a generic boilerplate is honesty about the audio-specific work — background modes, the audio session, remote commands — so you are not surprised by why your audio stops the second the screen locks.

Building a podcast app: from scratch vs with The Swift Kit

Frequently Asked Questions