diff --git a/ErsatzTV.Application/MediaSources/Commands/ScanLocalMediaSource.cs b/ErsatzTV.Application/MediaSources/Commands/ScanLocalMediaSource.cs
index 0e08d61da..9f5a1259b 100644
--- a/ErsatzTV.Application/MediaSources/Commands/ScanLocalMediaSource.cs
+++ b/ErsatzTV.Application/MediaSources/Commands/ScanLocalMediaSource.cs
@@ -4,6 +4,6 @@ using MediatR;
 
 namespace ErsatzTV.Application.MediaSources.Commands
 {
-    public record ScanLocalMediaSource(int MediaSourceId) : IRequest<Either<BaseError, string>>,
+    public record ScanLocalMediaSource(int MediaSourceId) : IRequest<Either<Seq<BaseError>, string>>,
         IBackgroundServiceRequest;
 }
diff --git a/ErsatzTV.Application/MediaSources/Commands/ScanLocalMediaSourceHandler.cs b/ErsatzTV.Application/MediaSources/Commands/ScanLocalMediaSourceHandler.cs
index 1f98dc31d..74c96e649 100644
--- a/ErsatzTV.Application/MediaSources/Commands/ScanLocalMediaSourceHandler.cs
+++ b/ErsatzTV.Application/MediaSources/Commands/ScanLocalMediaSourceHandler.cs
@@ -1,18 +1,21 @@
-using System.IO;
+using System;
+using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
 using MediatR;
+using static LanguageExt.Prelude;
 using Unit = LanguageExt.Unit;
 
 namespace ErsatzTV.Application.MediaSources.Commands
 {
-    public class ScanLocalMediaSourceHandler : IRequestHandler<ScanLocalMediaSource, Either<BaseError, string>>
+    public class ScanLocalMediaSourceHandler : IRequestHandler<ScanLocalMediaSource, Either<Seq<BaseError>, string>>
     {
         private readonly IConfigElementRepository _configElementRepository;
         private readonly IEntityLocker _entityLocker;
@@ -34,11 +37,11 @@ namespace ErsatzTV.Application.MediaSources.Commands
             _entityLocker = entityLocker;
         }
 
-        public Task<Either<BaseError, string>>
+        public Task<Either<Seq<BaseError>, string>>
             Handle(ScanLocalMediaSource request, CancellationToken cancellationToken) =>
             Validate(request)
                 .MapT(parameters => PerformScan(parameters).Map(_ => parameters.LocalMediaSource.Folder))
-                .Bind(v => v.ToEitherAsync());
+                .Bind(v => v.ToEither().MapAsync<Seq<BaseError>, Task<string>, string>(identity));
 
         private async Task<Unit> PerformScan(RequestParameters parameters)
         {
@@ -52,21 +55,33 @@ namespace ErsatzTV.Application.MediaSources.Commands
                     break;
             }
 
+            parameters.LocalMediaSource.LastScan = DateTimeOffset.Now;
+            await _mediaSourceRepository.Update(parameters.LocalMediaSource);
             _entityLocker.UnlockMediaSource(parameters.LocalMediaSource.Id);
 
             return Unit.Default;
         }
 
         private async Task<Validation<BaseError, RequestParameters>> Validate(ScanLocalMediaSource request) =>
-            (await LocalMediaSourceMustExist(request), await ValidateFFprobePath())
+            (await ValidateLocalMediaSource(request), await ValidateFFprobePath())
             .Apply((localMediaSource, ffprobePath) => new RequestParameters(localMediaSource, ffprobePath));
 
+        private Task<Validation<BaseError, LocalMediaSource>> ValidateLocalMediaSource(ScanLocalMediaSource request) =>
+            LocalMediaSourceMustExist(request).BindT(ValidateLastScan);
+
         private Task<Validation<BaseError, LocalMediaSource>> LocalMediaSourceMustExist(
             ScanLocalMediaSource request) =>
             _mediaSourceRepository.Get(request.MediaSourceId)
                 .Map(maybeMediaSource => maybeMediaSource.Map(ms => ms as LocalMediaSource))
                 .Map(v => v.ToValidation<BaseError>($"Local media source {request.MediaSourceId} does not exist."));
 
+        private Task<Validation<BaseError, LocalMediaSource>> ValidateLastScan(
+            LocalMediaSource localMediaSource) =>
+            Optional(localMediaSource)
+                .Filter(lms => lms.LastScan is null || lms.LastScan < DateTimeOffset.Now - TimeSpan.FromHours(6))
+                .ToValidation<BaseError>(new MediaSourceRecentlyScanned(localMediaSource.Folder))
+                .AsTask();
+
         private Task<Validation<BaseError, string>> ValidateFFprobePath() =>
             _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
                 .FilterT(File.Exists)
diff --git a/ErsatzTV.Core/Domain/MediaSource.cs b/ErsatzTV.Core/Domain/MediaSource.cs
index c8c604240..dd81b6afa 100644
--- a/ErsatzTV.Core/Domain/MediaSource.cs
+++ b/ErsatzTV.Core/Domain/MediaSource.cs
@@ -1,9 +1,12 @@
-namespace ErsatzTV.Core.Domain
+using System;
+
+namespace ErsatzTV.Core.Domain
 {
     public abstract class MediaSource
     {
         public int Id { get; set; }
         public MediaSourceType SourceType { get; set; }
         public string Name { get; set; }
+        public DateTimeOffset? LastScan { get; set; }
     }
 }
diff --git a/ErsatzTV.Core/Errors/MediaSourceRecentlyScanned.cs b/ErsatzTV.Core/Errors/MediaSourceRecentlyScanned.cs
new file mode 100644
index 000000000..6342c54f1
--- /dev/null
+++ b/ErsatzTV.Core/Errors/MediaSourceRecentlyScanned.cs
@@ -0,0 +1,10 @@
+namespace ErsatzTV.Core.Errors
+{
+    public class MediaSourceRecentlyScanned : BaseError
+    {
+        public MediaSourceRecentlyScanned(string folder) :
+            base($"Media source {folder} was already scanned recently; skipping scan.")
+        {
+        }
+    }
+}
diff --git a/ErsatzTV.Core/Interfaces/Repositories/IMediaSourceRepository.cs b/ErsatzTV.Core/Interfaces/Repositories/IMediaSourceRepository.cs
index 4469f45dd..e7a3f5955 100644
--- a/ErsatzTV.Core/Interfaces/Repositories/IMediaSourceRepository.cs
+++ b/ErsatzTV.Core/Interfaces/Repositories/IMediaSourceRepository.cs
@@ -14,6 +14,7 @@ namespace ErsatzTV.Core.Interfaces.Repositories
         Task<Option<MediaSource>> Get(int id);
         Task<Option<PlexMediaSource>> GetPlex(int id);
         Task<int> CountMediaItems(int id);
+        Task Update(LocalMediaSource localMediaSource);
         Task Update(PlexMediaSource plexMediaSource);
         Task Delete(int id);
     }
diff --git a/ErsatzTV.Infrastructure/Data/Repositories/MediaSourceRepository.cs b/ErsatzTV.Infrastructure/Data/Repositories/MediaSourceRepository.cs
index 3e1fab024..d1462f4d3 100644
--- a/ErsatzTV.Infrastructure/Data/Repositories/MediaSourceRepository.cs
+++ b/ErsatzTV.Infrastructure/Data/Repositories/MediaSourceRepository.cs
@@ -60,11 +60,15 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
         public Task<int> CountMediaItems(int id) =>
             _dbContext.MediaItems.CountAsync(i => i.MediaSourceId == id);
 
-        public async Task Update(PlexMediaSource plexMediaSource)
-        {
-            _dbContext.PlexMediaSources.Update(plexMediaSource);
-            await _dbContext.SaveChangesAsync();
-        }
+        public Task Update(LocalMediaSource localMediaSource) =>
+            _dbContext.LocalMediaSources.Update(localMediaSource)
+                .AsTask()
+                .Bind(_ => _dbContext.SaveChangesAsync());
+
+        public Task Update(PlexMediaSource plexMediaSource) =>
+            _dbContext.PlexMediaSources.Update(plexMediaSource)
+                .AsTask()
+                .Bind(_ => _dbContext.SaveChangesAsync());
 
         public async Task Delete(int id)
         {
diff --git a/ErsatzTV.Infrastructure/Migrations/20210222120255_MediaSourceLastScan.Designer.cs b/ErsatzTV.Infrastructure/Migrations/20210222120255_MediaSourceLastScan.Designer.cs
new file mode 100644
index 000000000..13f38c1ba
--- /dev/null
+++ b/ErsatzTV.Infrastructure/Migrations/20210222120255_MediaSourceLastScan.Designer.cs
@@ -0,0 +1,1308 @@
+// <auto-generated />
+using System;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace ErsatzTV.Infrastructure.Migrations
+{
+    [DbContext(typeof(TvContext))]
+    [Migration("20210222120255_MediaSourceLastScan")]
+    partial class MediaSourceLastScan
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "5.0.3");
+
+            modelBuilder.Entity("ErsatzTV.Core.AggregateModels.GenericIntegerId", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("INTEGER");
+
+                    b.ToView("No table or view exists for GenericIntegerId");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.AggregateModels.MediaCollectionSummary", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsSimple")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ItemCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.ToView("No table or view exists for MediaCollectionSummary");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.AggregateModels.MediaItemSummary", b =>
+                {
+                    b.Property<int>("MediaItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Poster")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Subtitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.ToView("No table or view exists for MediaItemSummary");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Channel", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("FFmpegProfileId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Logo")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Number")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("StreamingMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("UniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FFmpegProfileId");
+
+                    b.HasIndex("Number")
+                        .IsUnique();
+
+                    b.ToTable("Channels");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ConfigElement", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Key")
+                        .IsUnique();
+
+                    b.ToTable("ConfigElements");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.FFmpegProfile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("AudioBitrate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("AudioBufferSize")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("AudioChannels")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AudioCodec")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AudioSampleRate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("AudioVolume")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("NormalizeAudio")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("NormalizeAudioCodec")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("NormalizeResolution")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("NormalizeVideoCodec")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ResolutionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ThreadCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("Transcode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("VideoBitrate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("VideoBufferSize")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("VideoCodec")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ResolutionId");
+
+                    b.ToTable("FFmpegProfiles");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("MediaCollections");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("LastWriteTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MediaSourceId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Poster")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("PosterLastWriteTime")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaSourceId");
+
+                    b.ToTable("MediaItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaSource", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("LastScan")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("SourceType")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("MediaSources");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MovieMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ContentRating")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LastWriteTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MovieId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("Premiered")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Source")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Tagline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MovieId")
+                        .IsUnique();
+
+                    b.ToTable("MovieMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Playout", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ChannelId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProgramScheduleId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProgramSchedulePlayoutType")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChannelId");
+
+                    b.HasIndex("ProgramScheduleId");
+
+                    b.ToTable("Playouts");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("Finish")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MediaItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("Start")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.ToTable("PlayoutItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutProgramScheduleAnchor", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("CollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("CollectionType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProgramScheduleId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("ProgramScheduleId");
+
+                    b.ToTable("PlayoutProgramScheduleItemAnchors");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaSourceConnection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("PlexMediaSourceId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Uri")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlexMediaSourceId");
+
+                    b.ToTable("PlexMediaSourceConnections");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaSourceLibrary", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MediaType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("PlexMediaSourceId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlexMediaSourceId");
+
+                    b.ToTable("PlexMediaSourceLibraries");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramSchedule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MediaCollectionPlaybackOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("ProgramSchedules");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("CollectionType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MediaCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProgramScheduleId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeSpan?>("StartTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("TelevisionSeasonId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("TelevisionShowId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaCollectionId");
+
+                    b.HasIndex("ProgramScheduleId");
+
+                    b.HasIndex("TelevisionSeasonId");
+
+                    b.HasIndex("TelevisionShowId");
+
+                    b.ToTable("ProgramScheduleItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Resolution", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Height")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Width")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Resolutions");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TelevisionEpisodeMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("Aired")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Episode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("LastWriteTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Season")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Source")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("TelevisionEpisodeId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TelevisionEpisodeId")
+                        .IsUnique();
+
+                    b.ToTable("TelevisionEpisodeMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TelevisionSeason", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Number")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Poster")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("PosterLastWriteTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("TelevisionShowId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TelevisionShowId");
+
+                    b.ToTable("TelevisionSeasons");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TelevisionShow", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Poster")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("PosterLastWriteTime")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TelevisionShows");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TelevisionShowMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("LastWriteTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Source")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("TelevisionShowId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TelevisionShowId")
+                        .IsUnique();
+
+                    b.ToTable("TelevisionShowMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TelevisionShowSource", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Discriminator")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("TelevisionShowId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TelevisionShowId");
+
+                    b.ToTable("TelevisionShowSource");
+
+                    b.HasDiscriminator<string>("Discriminator").HasValue("TelevisionShowSource");
+                });
+
+            modelBuilder.Entity("MovieMediaItemSimpleMediaCollection", b =>
+                {
+                    b.Property<int>("MoviesId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("SimpleMediaCollectionsId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("MoviesId", "SimpleMediaCollectionsId");
+
+                    b.HasIndex("SimpleMediaCollectionsId");
+
+                    b.ToTable("SimpleMediaCollectionMovies");
+                });
+
+            modelBuilder.Entity("SimpleMediaCollectionTelevisionEpisodeMediaItem", b =>
+                {
+                    b.Property<int>("SimpleMediaCollectionsId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("TelevisionEpisodesId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("SimpleMediaCollectionsId", "TelevisionEpisodesId");
+
+                    b.HasIndex("TelevisionEpisodesId");
+
+                    b.ToTable("SimpleMediaCollectionEpisodes");
+                });
+
+            modelBuilder.Entity("SimpleMediaCollectionTelevisionSeason", b =>
+                {
+                    b.Property<int>("SimpleMediaCollectionsId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("TelevisionSeasonsId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("SimpleMediaCollectionsId", "TelevisionSeasonsId");
+
+                    b.HasIndex("TelevisionSeasonsId");
+
+                    b.ToTable("SimpleMediaCollectionSeasons");
+                });
+
+            modelBuilder.Entity("SimpleMediaCollectionTelevisionShow", b =>
+                {
+                    b.Property<int>("SimpleMediaCollectionsId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("TelevisionShowsId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("SimpleMediaCollectionsId", "TelevisionShowsId");
+
+                    b.HasIndex("TelevisionShowsId");
+
+                    b.ToTable("SimpleMediaCollectionShows");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SimpleMediaCollection", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaCollection");
+
+                    b.ToTable("SimpleMediaCollections");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MovieMediaItem", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.Property<int>("MetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.ToTable("Movies");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TelevisionEpisodeMediaItem", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.Property<int>("SeasonId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasIndex("SeasonId");
+
+                    b.ToTable("TelevisionEpisodes");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LocalMediaSource", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaSource");
+
+                    b.Property<string>("Folder")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MediaType")
+                        .HasColumnType("INTEGER");
+
+                    b.ToTable("LocalMediaSources");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaSource", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaSource");
+
+                    b.Property<string>("ClientIdentifier")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProductVersion")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("PlexMediaSources");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemDuration", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.ProgramScheduleItem");
+
+                    b.Property<bool>("OfflineTail")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeSpan>("PlayoutDuration")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("ProgramScheduleDurationItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemFlood", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.ProgramScheduleItem");
+
+                    b.ToTable("ProgramScheduleFloodItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemMultiple", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.ProgramScheduleItem");
+
+                    b.Property<int>("Count")
+                        .HasColumnType("INTEGER");
+
+                    b.ToTable("ProgramScheduleMultipleItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemOne", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.ProgramScheduleItem");
+
+                    b.ToTable("ProgramScheduleOneItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LocalTelevisionShowSource", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.TelevisionShowSource");
+
+                    b.Property<int>("MediaSourceId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.HasIndex("MediaSourceId");
+
+                    b.HasDiscriminator().HasValue("LocalTelevisionShowSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Channel", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.FFmpegProfile", "FFmpegProfile")
+                        .WithMany()
+                        .HasForeignKey("FFmpegProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FFmpegProfile");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.FFmpegProfile", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Resolution", "Resolution")
+                        .WithMany()
+                        .HasForeignKey("ResolutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Resolution");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", "Source")
+                        .WithMany()
+                        .HasForeignKey("MediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("ErsatzTV.Core.Domain.MediaItemStatistics", "Statistics", b1 =>
+                        {
+                            b1.Property<int>("MediaItemId")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<string>("AudioCodec")
+                                .HasColumnType("TEXT");
+
+                            b1.Property<string>("DisplayAspectRatio")
+                                .HasColumnType("TEXT");
+
+                            b1.Property<TimeSpan>("Duration")
+                                .HasColumnType("TEXT");
+
+                            b1.Property<int>("Height")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<DateTime?>("LastWriteTime")
+                                .HasColumnType("TEXT");
+
+                            b1.Property<string>("SampleAspectRatio")
+                                .HasColumnType("TEXT");
+
+                            b1.Property<string>("VideoCodec")
+                                .HasColumnType("TEXT");
+
+                            b1.Property<int>("VideoScanType")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int>("Width")
+                                .HasColumnType("INTEGER");
+
+                            b1.HasKey("MediaItemId");
+
+                            b1.ToTable("MediaItems");
+
+                            b1.WithOwner()
+                                .HasForeignKey("MediaItemId");
+                        });
+
+                    b.Navigation("Source");
+
+                    b.Navigation("Statistics");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MovieMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMediaItem", "Movie")
+                        .WithOne("Metadata")
+                        .HasForeignKey("ErsatzTV.Core.Domain.MovieMetadata", "MovieId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Movie");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Playout", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Channel", "Channel")
+                        .WithMany("Playouts")
+                        .HasForeignKey("ChannelId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramSchedule", "ProgramSchedule")
+                        .WithMany("Playouts")
+                        .HasForeignKey("ProgramScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("ErsatzTV.Core.Domain.PlayoutAnchor", "Anchor", b1 =>
+                        {
+                            b1.Property<int>("PlayoutId")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int>("NextScheduleItemId")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<DateTimeOffset>("NextStart")
+                                .HasColumnType("TEXT");
+
+                            b1.HasKey("PlayoutId");
+
+                            b1.HasIndex("NextScheduleItemId");
+
+                            b1.ToTable("Playouts");
+
+                            b1.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", "NextScheduleItem")
+                                .WithMany()
+                                .HasForeignKey("NextScheduleItemId")
+                                .OnDelete(DeleteBehavior.Cascade)
+                                .IsRequired();
+
+                            b1.WithOwner()
+                                .HasForeignKey("PlayoutId");
+
+                            b1.Navigation("NextScheduleItem");
+                        });
+
+                    b.Navigation("Anchor");
+
+                    b.Navigation("Channel");
+
+                    b.Navigation("ProgramSchedule");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("Items")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("Playout");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutProgramScheduleAnchor", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("ProgramScheduleAnchors")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramSchedule", "ProgramSchedule")
+                        .WithMany()
+                        .HasForeignKey("ProgramScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("ErsatzTV.Core.Domain.MediaCollectionEnumeratorState", "EnumeratorState", b1 =>
+                        {
+                            b1.Property<int>("PlayoutProgramScheduleAnchorId")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int>("Index")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int>("Seed")
+                                .HasColumnType("INTEGER");
+
+                            b1.HasKey("PlayoutProgramScheduleAnchorId");
+
+                            b1.ToTable("PlayoutProgramScheduleItemAnchors");
+
+                            b1.WithOwner()
+                                .HasForeignKey("PlayoutProgramScheduleAnchorId");
+                        });
+
+                    b.Navigation("EnumeratorState");
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("ProgramSchedule");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaSourceConnection", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.PlexMediaSource", null)
+                        .WithMany("Connections")
+                        .HasForeignKey("PlexMediaSourceId");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaSourceLibrary", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.PlexMediaSource", null)
+                        .WithMany("Libraries")
+                        .HasForeignKey("PlexMediaSourceId");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaCollection", "MediaCollection")
+                        .WithMany()
+                        .HasForeignKey("MediaCollectionId");
+
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramSchedule", "ProgramSchedule")
+                        .WithMany("Items")
+                        .HasForeignKey("ProgramScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.TelevisionSeason", "TelevisionSeason")
+                        .WithMany()
+                        .HasForeignKey("TelevisionSeasonId");
+
+                    b.HasOne("ErsatzTV.Core.Domain.TelevisionShow", "TelevisionShow")
+                        .WithMany()
+                        .HasForeignKey("TelevisionShowId");
+
+                    b.Navigation("MediaCollection");
+
+                    b.Navigation("ProgramSchedule");
+
+                    b.Navigation("TelevisionSeason");
+
+                    b.Navigation("TelevisionShow");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TelevisionEpisodeMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.TelevisionEpisodeMediaItem", "TelevisionEpisode")
+                        .WithOne("Metadata")
+                        .HasForeignKey("ErsatzTV.Core.Domain.TelevisionEpisodeMetadata", "TelevisionEpisodeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("TelevisionEpisode");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TelevisionSeason", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.TelevisionShow", "TelevisionShow")
+                        .WithMany("Seasons")
+                        .HasForeignKey("TelevisionShowId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("TelevisionShow");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TelevisionShowMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.TelevisionShow", "TelevisionShow")
+                        .WithOne("Metadata")
+                        .HasForeignKey("ErsatzTV.Core.Domain.TelevisionShowMetadata", "TelevisionShowId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("TelevisionShow");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TelevisionShowSource", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.TelevisionShow", "TelevisionShow")
+                        .WithMany("Sources")
+                        .HasForeignKey("TelevisionShowId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("TelevisionShow");
+                });
+
+            modelBuilder.Entity("MovieMediaItemSimpleMediaCollection", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMediaItem", null)
+                        .WithMany()
+                        .HasForeignKey("MoviesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.SimpleMediaCollection", null)
+                        .WithMany()
+                        .HasForeignKey("SimpleMediaCollectionsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SimpleMediaCollectionTelevisionEpisodeMediaItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.SimpleMediaCollection", null)
+                        .WithMany()
+                        .HasForeignKey("SimpleMediaCollectionsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.TelevisionEpisodeMediaItem", null)
+                        .WithMany()
+                        .HasForeignKey("TelevisionEpisodesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SimpleMediaCollectionTelevisionSeason", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.SimpleMediaCollection", null)
+                        .WithMany()
+                        .HasForeignKey("SimpleMediaCollectionsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.TelevisionSeason", null)
+                        .WithMany()
+                        .HasForeignKey("TelevisionSeasonsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SimpleMediaCollectionTelevisionShow", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.SimpleMediaCollection", null)
+                        .WithMany()
+                        .HasForeignKey("SimpleMediaCollectionsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.TelevisionShow", null)
+                        .WithMany()
+                        .HasForeignKey("TelevisionShowsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SimpleMediaCollection", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaCollection", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.SimpleMediaCollection", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MovieMediaItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.MovieMediaItem", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TelevisionEpisodeMediaItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.TelevisionEpisodeMediaItem", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.TelevisionSeason", "Season")
+                        .WithMany("Episodes")
+                        .HasForeignKey("SeasonId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Season");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LocalMediaSource", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.LocalMediaSource", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaSource", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexMediaSource", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemDuration", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.ProgramScheduleItemDuration", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemFlood", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.ProgramScheduleItemFlood", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemMultiple", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.ProgramScheduleItemMultiple", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemOne", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.ProgramScheduleItemOne", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LocalTelevisionShowSource", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.LocalMediaSource", "MediaSource")
+                        .WithMany()
+                        .HasForeignKey("MediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Channel", b =>
+                {
+                    b.Navigation("Playouts");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Playout", b =>
+                {
+                    b.Navigation("Items");
+
+                    b.Navigation("ProgramScheduleAnchors");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramSchedule", b =>
+                {
+                    b.Navigation("Items");
+
+                    b.Navigation("Playouts");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TelevisionSeason", b =>
+                {
+                    b.Navigation("Episodes");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TelevisionShow", b =>
+                {
+                    b.Navigation("Metadata");
+
+                    b.Navigation("Seasons");
+
+                    b.Navigation("Sources");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MovieMediaItem", b =>
+                {
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TelevisionEpisodeMediaItem", b =>
+                {
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaSource", b =>
+                {
+                    b.Navigation("Connections");
+
+                    b.Navigation("Libraries");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/ErsatzTV.Infrastructure/Migrations/20210222120255_MediaSourceLastScan.cs b/ErsatzTV.Infrastructure/Migrations/20210222120255_MediaSourceLastScan.cs
new file mode 100644
index 000000000..c4a3a11bf
--- /dev/null
+++ b/ErsatzTV.Infrastructure/Migrations/20210222120255_MediaSourceLastScan.cs
@@ -0,0 +1,24 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace ErsatzTV.Infrastructure.Migrations
+{
+    public partial class MediaSourceLastScan : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<DateTimeOffset>(
+                name: "LastScan",
+                table: "MediaSources",
+                type: "TEXT",
+                nullable: true);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "LastScan",
+                table: "MediaSources");
+        }
+    }
+}
diff --git a/ErsatzTV.Infrastructure/Migrations/TvContextModelSnapshot.cs b/ErsatzTV.Infrastructure/Migrations/TvContextModelSnapshot.cs
index ebc91a0a9..c0b9613ae 100644
--- a/ErsatzTV.Infrastructure/Migrations/TvContextModelSnapshot.cs
+++ b/ErsatzTV.Infrastructure/Migrations/TvContextModelSnapshot.cs
@@ -248,6 +248,9 @@ namespace ErsatzTV.Infrastructure.Migrations
                         .ValueGeneratedOnAdd()
                         .HasColumnType("INTEGER");
 
+                    b.Property<DateTimeOffset?>("LastScan")
+                        .HasColumnType("TEXT");
+
                     b.Property<string>("Name")
                         .HasColumnType("TEXT");
 
diff --git a/ErsatzTV/Services/WorkerService.cs b/ErsatzTV/Services/WorkerService.cs
index caf56afd5..5c918f2a3 100644
--- a/ErsatzTV/Services/WorkerService.cs
+++ b/ErsatzTV/Services/WorkerService.cs
@@ -6,6 +6,7 @@ using ErsatzTV.Application;
 using ErsatzTV.Application.MediaSources.Commands;
 using ErsatzTV.Application.Playouts.Commands;
 using ErsatzTV.Core;
+using ErsatzTV.Core.Errors;
 using LanguageExt;
 using MediatR;
 using Microsoft.Extensions.DependencyInjection;
@@ -56,17 +57,28 @@ namespace ErsatzTV.Services
                                     error.Value));
                             break;
                         case ScanLocalMediaSource scanLocalMediaSource:
-                            Either<BaseError, string> scanResult = await mediator.Send(
+                            Either<Seq<BaseError>, string> scanResult = await mediator.Send(
                                 scanLocalMediaSource,
                                 cancellationToken);
                             scanResult.BiIter(
                                 name => _logger.LogDebug(
                                     "Done scanning local media source {MediaSource}",
                                     name),
-                                error => _logger.LogWarning(
-                                    "Unable to scan local media source {MediaSourceId}: {Error}",
-                                    scanLocalMediaSource.MediaSourceId,
-                                    error.Value));
+                                errors =>
+                                {
+                                    BaseError error = errors.Head;
+                                    if (error is MediaSourceRecentlyScanned recentlyScanned)
+                                    {
+                                        _logger.LogInformation(recentlyScanned.Value);
+                                    }
+                                    else
+                                    {
+                                        _logger.LogWarning(
+                                            "Unable to scan local media source {MediaSourceId}: {Error}",
+                                            scanLocalMediaSource.MediaSourceId,
+                                            error.Value);
+                                    }
+                                });
                             break;
                     }
                 }