diff --git a/cmd/updater/updater.py b/cmd/updater/updater.py
index 82db10b..df37c67 100644
--- a/cmd/updater/updater.py
+++ b/cmd/updater/updater.py
@@ -34,13 +34,14 @@ def _update_feed(hash_id):
     page_size = int(feed.get('PageSize', DEFAULT_PAGE_SIZE))
     last_id = feed.get('LastID', None)
     episodes = feed.get('Episodes', [])
+    item_url = feed['ItemURL']
 
     # Rebuild episode list from scratch
     if not last_id:
         episodes = []
 
     start = time.time()
-    _, items, new_last_id = _get_updates(1, page_size, _get_url(feed), _get_format(feed), last_id)
+    _, items, new_last_id = _get_updates(1, page_size, item_url, _get_format(feed), last_id)
     end = time.time()
 
     print('Got feed update: new {}, current {}. Update took: {}'.format(len(items), len(episodes), end-start))
@@ -67,7 +68,7 @@ def _update_feed(hash_id):
 def _query_feed(hash_id):
     response = feeds_table.get_item(
         Key={'HashID': hash_id},
-        ProjectionExpression='#prov,#type,#size,#fmt,#quality,#level,#id,#last_id,#episodes,#updated_at',
+        ProjectionExpression='#prov,#type,#size,#fmt,#quality,#level,#id,#last_id,#episodes,#updated_at,#item_url',
         ExpressionAttributeNames={
             '#prov': 'Provider',
             '#type': 'LinkType',
@@ -79,6 +80,7 @@ def _query_feed(hash_id):
             '#last_id': 'LastID',
             '#episodes': 'Episodes',
             '#updated_at': 'UpdatedAt',
+            '#item_url': 'ItemURL',
         },
     )
 
@@ -140,37 +142,6 @@ def _get_format(feed):
             return 'worstaudio'
 
 
-def _get_url(feed):
-    provider = feed['Provider']
-    link_type = feed['LinkType']
-    item_id = feed['ItemID']
-
-    if provider == 'youtube':
-
-        if link_type == 'playlist':
-            return 'https://www.youtube.com/playlist?list={}'.format(item_id)
-        elif link_type == 'channel':
-            return 'https://www.youtube.com/channel/{}'.format(item_id)
-        elif link_type == 'user':
-            return 'https://www.youtube.com/user/{}'.format(item_id)
-        else:
-            raise ValueError('Unsupported link type')
-
-    elif provider == 'vimeo':
-
-        if link_type == 'channel':
-            return 'https://vimeo.com/channels/{}'.format(item_id)
-        elif link_type == 'group':
-            return 'http://vimeo.com/groups/{}'.format(item_id)
-        elif link_type == 'user':
-            return 'https://vimeo.com/{}'.format(item_id)
-        else:
-            raise ValueError('Unsupported link type')
-
-    else:
-        raise ValueError('Unsupported provider')
-
-
 def _get_updates(start, count, url, fmt, last_id=None):
     if start < 1:
         raise ValueError('Invalid start value')
@@ -219,15 +190,18 @@ def _get_updates(start, count, url, fmt, last_id=None):
             # Query video metadata from YouTube
             result = ytdl.process_ie_result(entry, download=False)
 
+            # Convert '20190101' to unix time
+            date_str = result.get('upload_date')
+            date = datetime.strptime(date_str, '%Y%m%d')
+
             videos.append({
                 'ID': video_id,
                 'Title': result.get('title'),
                 'Description': result.get('description'),
                 'Thumbnail': result.get('thumbnail'),
-                'Duration': result.get('duration'),
+                'Duration': int(result.get('duration')),
                 'VideoURL': result.get('webpage_url'),
-                'UploadDate': result.get('upload_date'),
-                'Ext': result.get('ext'),
+                'PubDate': int(date.timestamp()),
                 'Size': _get_size(result, selector),
             })
 
diff --git a/docker-compose.yml b/docker-compose.yml
index 93f77ef..9b704b4 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -22,13 +22,6 @@ services:
       - AWS_ACCESS_SECRET={AWS_ACCESS_SECRET}
       - DYNAMO_FEEDS_TABLE_NAME=Prod_Feeds
       - DYNAMO_PLEDGES_TABLE_NAME=Prod_Pledges
-    logging:
-      driver: "awslogs"
-      options:
-        awslogs-region: "us-east-1"
-        awslogs-group: "Prod"
-        awslogs-stream: "Backend"
-        awslogs-multiline-pattern: "{"
   redis:
     image: redis:5.0.3
     container_name: redis
diff --git a/pkg/builders/vimeo.go b/pkg/builders/vimeo.go
index 1b5ebb1..4329cc9 100644
--- a/pkg/builders/vimeo.go
+++ b/pkg/builders/vimeo.go
@@ -3,6 +3,7 @@ package builders
 import (
 	"net/http"
 	"strconv"
+	"time"
 
 	itunes "github.com/mxpv/podcast"
 	"github.com/pkg/errors"
@@ -53,6 +54,8 @@ func (v *VimeoBuilder) queryChannel(feed *model.Feed) (*itunes.Podcast, error) {
 	podcast.AddCategory(defaultCategory, nil)
 	podcast.IAuthor = ch.User.Name
 
+	feed.PubDate = ch.CreatedTime
+
 	return &podcast, nil
 }
 
@@ -75,6 +78,8 @@ func (v *VimeoBuilder) queryGroup(feed *model.Feed) (*itunes.Podcast, error) {
 	podcast.AddCategory(defaultCategory, nil)
 	podcast.IAuthor = gr.User.Name
 
+	feed.PubDate = gr.CreatedTime
+
 	return &podcast, nil
 }
 
@@ -97,6 +102,8 @@ func (v *VimeoBuilder) queryUser(feed *model.Feed) (*itunes.Podcast, error) {
 	podcast.AddCategory(defaultCategory, nil)
 	podcast.IAuthor = user.Name
 
+	feed.PubDate = user.CreatedTime
+
 	return &podcast, nil
 }
 
@@ -120,21 +127,29 @@ func (v *VimeoBuilder) queryVideos(getVideos getVideosFunc, podcast *itunes.Podc
 		}
 
 		for _, video := range videos {
+
+			var (
+				videoID  = strconv.Itoa(video.GetID())
+				videoURL = video.Link
+				duration = int64(video.Duration)
+				size     = v.getVideoSize(video)
+				image    = v.selectImage(video.Pictures, feed.Quality)
+			)
+
 			item := itunes.Item{}
 
-			item.GUID = strconv.Itoa(video.GetID())
-			item.Link = video.Link
+			item.GUID = videoID
+			item.Link = videoURL
 			item.Title = video.Name
 			item.Description = video.Description
 			if item.Description == "" {
 				item.Description = " " // Videos can be without description, workaround for AddItem
 			}
 
-			item.AddDuration(int64(video.Duration))
+			item.AddDuration(duration)
 			item.AddPubDate(&video.CreatedTime)
-			item.AddImage(v.selectImage(video.Pictures, feed.Quality))
+			item.AddImage(image)
 
-			size := v.getVideoSize(video)
 			item.AddEnclosure(makeEnclosure(feed, item.GUID, size))
 
 			_, err = podcast.AddItem(item)
@@ -142,6 +157,17 @@ func (v *VimeoBuilder) queryVideos(getVideos getVideosFunc, podcast *itunes.Podc
 				return errors.Wrapf(err, "failed to add episode %s (%s)", item.GUID, item.Title)
 			}
 
+			feed.Episodes = append(feed.Episodes, &model.Item{
+				ID:          videoID,
+				Title:       item.Title,
+				Description: item.Description,
+				Duration:    duration,
+				Size:        size,
+				PubDate:     video.CreatedTime,
+				Thumbnail:   image,
+				VideoURL:    videoURL,
+			})
+
 			added++
 		}
 
@@ -153,33 +179,70 @@ func (v *VimeoBuilder) queryVideos(getVideos getVideosFunc, podcast *itunes.Podc
 	}
 }
 
-func (v *VimeoBuilder) Build(feed *model.Feed) (podcast *itunes.Podcast, err error) {
+func (v *VimeoBuilder) Build(feed *model.Feed) error {
+	feed.Episodes = []*model.Item{}
+
 	if feed.LinkType == api.LinkTypeChannel {
-		if podcast, err = v.queryChannel(feed); err == nil {
-			err = v.queryVideos(v.client.Channels.ListVideo, podcast, feed)
+		podcast, err := v.queryChannel(feed)
+		if err != nil {
+			return err
 		}
 
-		return
+		if err := v.queryVideos(v.client.Channels.ListVideo, podcast, feed); err != nil {
+			return err
+		}
+
+		v.updateFeed(feed, podcast)
+		return nil
 	}
 
 	if feed.LinkType == api.LinkTypeGroup {
-		if podcast, err = v.queryGroup(feed); err == nil {
-			err = v.queryVideos(v.client.Groups.ListVideo, podcast, feed)
+		podcast, err := v.queryGroup(feed)
+		if err != nil {
+			return err
 		}
 
-		return
+		if err := v.queryVideos(v.client.Groups.ListVideo, podcast, feed); err != nil {
+			return err
+		}
+
+		v.updateFeed(feed, podcast)
+		return nil
 	}
 
 	if feed.LinkType == api.LinkTypeUser {
-		if podcast, err = v.queryUser(feed); err == nil {
-			err = v.queryVideos(v.client.Users.ListVideo, podcast, feed)
+		podcast, err := v.queryUser(feed)
+		if err != nil {
+			return err
 		}
 
-		return
+		if err := v.queryVideos(v.client.Users.ListVideo, podcast, feed); err != nil {
+			return err
+		}
+
+		v.updateFeed(feed, podcast)
+		return nil
 	}
 
-	err = errors.New("unsupported feed type")
-	return
+	return errors.New("unsupported feed type")
+}
+
+func (v *VimeoBuilder) updateFeed(feed *model.Feed, podcast *itunes.Podcast) {
+	feed.Title = podcast.Title
+	feed.Description = podcast.Description
+	feed.Author = podcast.IAuthor
+	feed.ItemURL = podcast.Link
+	feed.UpdatedAt = time.Now().UTC()
+
+	if podcast.IImage != nil {
+		feed.CoverArt = podcast.IImage.HREF
+	}
+
+	if len(feed.Episodes) > 0 {
+		feed.LastID = feed.Episodes[0].ID
+	} else {
+		feed.LastID = ""
+	}
 }
 
 func (v *VimeoBuilder) GetVideoCount(feed *model.Feed) (uint64, error) {
diff --git a/pkg/builders/youtube.go b/pkg/builders/youtube.go
index 0faba03..48b5de1 100644
--- a/pkg/builders/youtube.go
+++ b/pkg/builders/youtube.go
@@ -161,6 +161,7 @@ func (yt *YouTubeBuilder) queryFeed(feed *model.Feed) (*itunes.Podcast, string,
 		desc       string
 		link       string // URL link to YouTube resource
 		itemID     string // ID of YouTube's channel, user or playlist
+		author     string
 		pubDate    time.Time
 		thumbnails *youtube.ThumbnailDetails
 	)
@@ -178,8 +179,10 @@ func (yt *YouTubeBuilder) queryFeed(feed *model.Feed) (*itunes.Podcast, string,
 
 		if channel.Kind == "youtube#channel" {
 			link = fmt.Sprintf("https://youtube.com/channel/%s", channel.Id)
+			author = title
 		} else {
 			link = fmt.Sprintf("https://youtube.com/user/%s", channel.Snippet.CustomUrl)
+			author = channel.Snippet.CustomUrl
 		}
 
 		itemID = channel.ContentDetails.RelatedPlaylists.Uploads
@@ -206,6 +209,8 @@ func (yt *YouTubeBuilder) queryFeed(feed *model.Feed) (*itunes.Podcast, string,
 
 		itemID = playlist.Id
 
+		author = title
+
 		if date, err := yt.parseDate(playlist.Snippet.PublishedAt); err != nil {
 			return nil, "", err
 		} else {
@@ -256,6 +261,15 @@ func (yt *YouTubeBuilder) queryFeed(feed *model.Feed) (*itunes.Podcast, string,
 		podcast.Language = feed.Language
 	}
 
+	// New interface
+	feed.Title = title
+	feed.Description = desc
+	feed.Author = author
+	feed.ItemURL = link
+	feed.UpdatedAt = time.Now().UTC()
+	feed.PubDate = pubDate
+	feed.CoverArt = image
+
 	return &podcast, itemID, nil
 }
 
@@ -297,9 +311,14 @@ func (yt *YouTubeBuilder) queryVideoDescriptions(
 	for _, video := range req.Items {
 		snippet := video.Snippet
 
+		var (
+			videoURL = fmt.Sprintf("https://youtube.com/watch?v=%s", video.Id)
+			image    = yt.selectThumbnail(snippet.Thumbnails, feed.Quality)
+		)
+
 		item := itunes.Item{
 			GUID:        video.Id,
-			Link:        fmt.Sprintf("https://youtube.com/watch?v=%s", video.Id),
+			Link:        videoURL,
 			Title:       snippet.Title,
 			Description: snippet.Description,
 			ISubtitle:   snippet.Title,
@@ -311,9 +330,7 @@ func (yt *YouTubeBuilder) queryVideoDescriptions(
 		}
 
 		item.AddSummary(desc)
-
-		// Select thumbnail
-		item.AddImage(yt.selectThumbnail(snippet.Thumbnails, feed.Quality))
+		item.AddImage(image)
 
 		// Parse date added to playlist / publication date
 		dateStr := ""
@@ -361,6 +378,22 @@ func (yt *YouTubeBuilder) queryVideoDescriptions(
 		if err != nil {
 			return errors.Wrapf(err, "failed to add item to podcast (id '%s')", video.Id)
 		}
+
+		// New interface
+
+		feed.Episodes = append(feed.Episodes, &model.Item{
+			ID:          video.Id,
+			Title:       item.Title,
+			Description: item.Description,
+			Thumbnail:   image,
+			Duration:    seconds,
+			Size:        size,
+			VideoURL:    videoURL,
+			PubDate:     pubDate,
+
+			// Need for sorting
+			Order: item.IOrder,
+		})
 	}
 
 	return nil
@@ -403,12 +436,13 @@ func (yt *YouTubeBuilder) queryItems(itemID string, feed *model.Feed, podcast *i
 	}
 }
 
-func (yt *YouTubeBuilder) Build(feed *model.Feed) (*itunes.Podcast, error) {
+func (yt *YouTubeBuilder) Build(feed *model.Feed)  error {
+	feed.Episodes = []*model.Item{}
 
 	// Query general information about feed (title, description, lang, etc)
 	podcast, itemID, err := yt.queryFeed(feed)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	// Get video descriptions
@@ -417,7 +451,7 @@ func (yt *YouTubeBuilder) Build(feed *model.Feed) (*itunes.Podcast, error) {
 	}
 
 	if err := yt.queryItems(itemID, feed, podcast); err != nil {
-		return nil, err
+		return err
 	}
 
 	// Sort episodes by <itunes:order> tag
@@ -428,7 +462,21 @@ func (yt *YouTubeBuilder) Build(feed *model.Feed) (*itunes.Podcast, error) {
 		return item1 < item2
 	})
 
-	return podcast, nil
+	// New interface
+
+	sort.Slice(feed.Episodes, func(i, j int) bool {
+		item1, _ := strconv.Atoi(feed.Episodes[i].Order)
+		item2, _ := strconv.Atoi(feed.Episodes[j].Order)
+		return item1 < item2
+	})
+
+	if len(feed.Episodes) > 0 {
+		feed.LastID = feed.Episodes[0].ID
+	} else {
+		feed.LastID = ""
+	}
+
+	return nil
 }
 
 func NewYouTubeBuilder(key string) (*YouTubeBuilder, error) {
diff --git a/pkg/builders/youtube_test.go b/pkg/builders/youtube_test.go
index a09cdca..8dfbc9c 100644
--- a/pkg/builders/youtube_test.go
+++ b/pkg/builders/youtube_test.go
@@ -50,34 +50,25 @@ func TestYT_BuildFeed(t *testing.T) {
 	for _, f := range feeds {
 		feed := f
 		t.Run(feed.ItemID, func(t *testing.T) {
-			podcast, err := builder.Build(feed)
-
+			err := builder.Build(feed)
 			require.NoError(t, err)
 
-			assert.NotEmpty(t, podcast.Title)
-			assert.NotEmpty(t, podcast.IAuthor)
-			assert.NotEmpty(t, podcast.Description)
+			assert.NotEmpty(t, feed.Title)
+			assert.NotEmpty(t, feed.Description)
+			assert.NotEmpty(t, feed.Author)
+			assert.NotEmpty(t, feed.ItemURL)
+			assert.NotEmpty(t, feed.LastID)
 
-			assert.NotNil(t, podcast.ISummary)
-			if podcast.ISummary != nil {
-				assert.NotEmpty(t, podcast.ISummary.Text)
-			}
+			assert.NotZero(t, len(feed.Episodes))
 
-			assert.NotZero(t, len(podcast.Items))
-
-			for _, item := range podcast.Items {
+			for _, item := range feed.Episodes {
 				assert.NotEmpty(t, item.Title)
-				assert.NotEmpty(t, item.Link)
-				assert.NotEmpty(t, item.IDuration)
-
-				assert.NotNil(t, item.ISummary)
-				if item.ISummary != nil {
-					assert.NotEmpty(t, item.ISummary.Text)
-				}
+				assert.NotEmpty(t, item.VideoURL)
+				assert.NotZero(t, item.Duration)
 
 				assert.NotEmpty(t, item.Title)
-				assert.NotEmpty(t, item.IAuthor)
 				assert.NotEmpty(t, item.Description)
+				assert.NotEmpty(t, item.Thumbnail)
 			}
 		})
 	}
diff --git a/pkg/feeds/feeds.go b/pkg/feeds/feeds.go
index 744d3ec..bac862d 100644
--- a/pkg/feeds/feeds.go
+++ b/pkg/feeds/feeds.go
@@ -14,13 +14,13 @@ import (
 )
 
 type Builder interface {
-	Build(feed *model.Feed) (podcast *itunes.Podcast, err error)
-	GetVideoCount(feed *model.Feed) (uint64, error)
+	Build(feed *model.Feed) error
 }
 
 type storage interface {
 	SaveFeed(feed *model.Feed) error
 	GetFeed(hashID string) (*model.Feed, error)
+	UpdateFeed(feed *model.Feed) error
 	GetMetadata(hashID string) (*model.Feed, error)
 	Downgrade(userID string, featureLevel int) ([]string, error)
 }
@@ -28,24 +28,52 @@ type storage interface {
 type cacheService interface {
 	Set(key, value string, ttl time.Duration) error
 	Get(key string) (string, error)
-
-	SaveItem(key string, item interface{}, exp time.Duration) error
-	GetItem(key string, item interface{}) error
-
-	SetMap(key string, fields map[string]interface{}, exp time.Duration) error
-	GetMap(key string, fields ...string) (map[string]string, error)
-
 	Invalidate(key ...string) error
 }
 
 type Service struct {
 	generator IDGen
-	db        storage
+	storage   storage
 	builders  map[api.Provider]Builder
 	cache     cacheService
 }
 
-func (s Service) makeFeed(req *api.CreateFeedRequest, identity *api.Identity) (*model.Feed, error) {
+func NewFeedService(db storage, cache cacheService, builders map[api.Provider]Builder) (*Service, error) {
+	idGen, err := NewIDGen()
+	if err != nil {
+		return nil, err
+	}
+
+	svc := &Service{
+		generator: idGen,
+		storage:   db,
+		builders:  builders,
+		cache:     cache,
+	}
+
+	return svc, nil
+}
+
+func (s *Service) CreateFeed(req *api.CreateFeedRequest, identity *api.Identity) (string, error) {
+	feed, err := s.makeFeed(req, identity)
+	if err != nil {
+		return "", err
+	}
+
+	// Make sure builder exists for this provider
+	_, ok := s.builders[feed.Provider]
+	if !ok {
+		return "", fmt.Errorf("failed to get builder for URL: %s", req.URL)
+	}
+
+	if err := s.storage.SaveFeed(feed); err != nil {
+		return "", err
+	}
+
+	return feed.HashID, nil
+}
+
+func (s *Service) makeFeed(req *api.CreateFeedRequest, identity *api.Identity) (*model.Feed, error) {
 	feed, err := parseURL(req.URL)
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to create feed for URL: %s", req.URL)
@@ -87,173 +115,139 @@ func (s Service) makeFeed(req *api.CreateFeedRequest, identity *api.Identity) (*
 	return feed, nil
 }
 
-func (s Service) CreateFeed(req *api.CreateFeedRequest, identity *api.Identity) (string, error) {
-	feed, err := s.makeFeed(req, identity)
-	if err != nil {
-		return "", err
-	}
-
-	// Make sure builder exists for this provider
-	_, ok := s.builders[feed.Provider]
-	if !ok {
-		return "", fmt.Errorf("failed to get builder for URL: %s", req.URL)
-	}
-
-	if err := s.db.SaveFeed(feed); err != nil {
-		return "", err
-	}
-
-	return feed.HashID, nil
-}
-
 func (s Service) QueryFeed(hashID string) (*model.Feed, error) {
-	return s.db.GetFeed(hashID)
+	return s.storage.GetFeed(hashID)
 }
 
-func (s Service) getVideoCount(feed *model.Feed, builder Builder) (uint64, bool) {
-	videoCount, err := builder.GetVideoCount(feed)
-	if err != nil {
-		return 0, false
+func makeEnclosure(feed *model.Feed, id string, lengthInBytes int64) (string, itunes.EnclosureType, int64) {
+	ext := "mp4"
+	contentType := itunes.MP4
+	if feed.Format == api.FormatAudio {
+		ext = "m4a"
+		contentType = itunes.M4A
 	}
 
-	return videoCount, true
+	url := fmt.Sprintf("http://podsync.net/download/%s/%s.%s", feed.HashID, id, ext)
+	return url, contentType, lengthInBytes
 }
 
-const (
-	feedKey       = "feed"
-	updatedAtKey  = "updatedAt"
-	videoCountKey = "videoCount"
-)
-
-func (s Service) getCachedFeed(hashID string) ([]byte, time.Time, uint64, error) {
-	cached, err := s.cache.GetMap(hashID, feedKey, updatedAtKey, videoCountKey)
-	if err != nil {
-		return nil, time.Time{}, 0, err
-	}
-
-	// Get feed body
-
-	body := []byte(cached[feedKey])
-
-	// Parse updated at
-
-	unixTime, err := strconv.ParseInt(cached[updatedAtKey], 10, 64)
-	if err != nil {
-		return nil, time.Time{}, 0, err
-	}
-
-	updatedAt := time.Unix(unixTime, 0)
-
-	// Parse video count
-
-	var videoCount uint64
-
-	if str, ok := cached[videoCountKey]; ok {
-		count, err := strconv.ParseUint(str, 10, 64)
-		if err != nil {
-			return nil, time.Time{}, 0, err
-		}
-
-		videoCount = count
-	}
-
-	// OK
-	return body, updatedAt, videoCount, nil
-}
-
-func (s Service) BuildFeed(hashID string) ([]byte, error) {
+func (s *Service) BuildFeed(hashID string) ([]byte, error) {
 	const (
-		feedRecordTTL   = 15 * 24 * time.Hour
-		cacheRecheckTTL = 10 * time.Minute
+		cacheTTL = 15 * time.Minute
 	)
 
-	var (
-		now         = time.Now().UTC()
-		verifyCache bool
-	)
-
-	// Check cached version first
-	body, updatedAt, currentCount, err := s.getCachedFeed(hashID)
+	cached, err := s.cache.Get(hashID)
 	if err == nil {
-		// We've succeded to retrieve data from Redis, check if it's up to date
-
-		// 1. If cached less than 15 minutes ago, just return data
-		if now.Sub(updatedAt) < cacheRecheckTTL {
-			return body, nil
-		}
-
-		// 2. Verify cache integrity by querying the number of episodes from YouTube
-		verifyCache = true
+		return []byte(cached), nil
 	}
 
-	// Query feed metadata from DynamoDB
+	// Query feed from DynamoDB
 
 	feed, err := s.QueryFeed(hashID)
 	if err != nil {
 		return nil, err
 	}
 
+	// Rebuild feed using YouTube API
+
 	builder, ok := s.builders[feed.Provider]
 	if !ok {
 		return nil, errors.Wrapf(err, "failed to get builder for feed: %s", hashID)
 	}
 
-	// 2. Check if cached version is still valid
-
-	// Query YouTube and check the number of videos.
-	// Most likely it'll remain the same, so we can return previously cached feed.
-	videoCount, videoOk := s.getVideoCount(feed, builder)
-
-	if verifyCache && videoOk {
-
-		if currentCount == videoCount {
-			// Cache is up to date, renew and save
-			err = s.cache.SetMap(hashID, map[string]interface{}{updatedAtKey: now.Unix()}, feedRecordTTL)
-			if err != nil {
-				return nil, errors.Wrap(err, "failed to cache item")
-			}
-
-			return body, nil
-		}
-	}
-
-	// Rebuild feed using YouTube API
-
 	log.Infof("building new feed %q", hashID)
 
-	podcast, err := builder.Build(feed)
-	if err != nil {
+	if err := builder.Build(feed); err != nil {
 		log.WithError(err).WithField("feed_id", hashID).Error("failed to build cache")
-
-		// If there is cached version - return it
-		if verifyCache {
-			return body, nil
-		}
-
 		return nil, err
 	}
 
-	newBody := podcast.String()
+	if err := s.storage.UpdateFeed(feed); err != nil {
+		log.WithError(err).WithField("feed_id", hashID).Error("failed to save feed to Dynamo")
+		return nil, err
+	}
+
+	podcast, err := s.buildPodcast(feed)
+	if err != nil {
+		return nil, err
+	}
+
+	body := podcast.String()
 
 	// Save to cache
 
-	data := map[string]interface{}{
-		feedKey: newBody,
-		updatedAtKey: now.Unix(),
-		videoCountKey: strconv.FormatUint(videoCount, 10),
+	if err := s.cache.Set(hashID, body, cacheTTL); err != nil {
+		log.WithError(err).Errorf("failed to save cache for feed %q", hashID)
+		return nil, err
 	}
 
-	err = s.cache.SetMap(hashID, data, feedRecordTTL)
+	return []byte(body), nil
+}
 
-	if err != nil {
-		log.WithError(err).Warnf("failed to save new feed %q to cache", hashID)
+func (s *Service) buildPodcast(feed *model.Feed) (*itunes.Podcast, error) {
+	const (
+		podsyncGenerator = "Podsync generator"
+		defaultCategory  = "TV & Film"
+	)
+
+	now := time.Now().UTC()
+
+	p := itunes.New(feed.Title, feed.ItemURL, feed.Description, &feed.PubDate, &now)
+	p.Generator = podsyncGenerator
+	p.AddSubTitle(feed.Title)
+	p.AddCategory(defaultCategory, nil)
+	p.AddImage(feed.CoverArt)
+	p.IAuthor = feed.Title
+	p.AddSummary(feed.Description)
+
+	if feed.Explicit {
+		p.IExplicit = "yes"
+	} else {
+		p.IExplicit = "no"
 	}
 
-	return []byte(newBody), nil
+	if feed.Language != "" {
+		p.Language = feed.Language
+	}
+
+	for i, episode := range feed.Episodes {
+		item := itunes.Item{
+			GUID:        episode.ID,
+			Link:        episode.VideoURL,
+			Title:       episode.Title,
+			Description: episode.Description,
+			ISubtitle:   episode.Title,
+			IOrder:      strconv.Itoa(i),
+		}
+
+		item.AddSummary(episode.Description)
+		item.AddImage(episode.Thumbnail)
+		item.AddPubDate(&episode.PubDate)
+		item.AddDuration(episode.Duration)
+		item.AddEnclosure(makeEnclosure(feed, episode.ID, episode.Size))
+
+		// p.AddItem requires description to be not empty, use workaround
+		if item.Description == "" {
+			item.Description = " "
+		}
+
+		if feed.Explicit {
+			item.IExplicit = "yes"
+		} else {
+			item.IExplicit = "no"
+		}
+
+		_, err := p.AddItem(item)
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to add item to podcast (id %q)", episode.ID)
+		}
+	}
+
+	return &p, nil
 }
 
 func (s Service) GetMetadata(hashID string) (*api.Metadata, error) {
-	feed, err := s.db.GetMetadata(hashID)
+	feed, err := s.storage.GetMetadata(hashID)
 	if err != nil {
 		return nil, err
 	}
@@ -273,7 +267,7 @@ func (s Service) Downgrade(patronID string, featureLevel int) error {
 
 	logger.Info("downgrading patron")
 
-	ids, err := s.db.Downgrade(patronID, featureLevel)
+	ids, err := s.storage.Downgrade(patronID, featureLevel)
 	if err != nil {
 		logger.WithError(err).Error("database error while downgrading patron")
 		return err
@@ -287,19 +281,3 @@ func (s Service) Downgrade(patronID string, featureLevel int) error {
 	logger.Info("successfully updated user")
 	return nil
 }
-
-func NewFeedService(db storage, cache cacheService, builders map[api.Provider]Builder) (*Service, error) {
-	idGen, err := NewIDGen()
-	if err != nil {
-		return nil, err
-	}
-
-	svc := &Service{
-		generator: idGen,
-		db:        db,
-		builders:  builders,
-		cache:     cache,
-	}
-
-	return svc, nil
-}
diff --git a/pkg/feeds/feeds_mock_test.go b/pkg/feeds/feeds_mock_test.go
index 83d2c3f..f97f9e8 100644
--- a/pkg/feeds/feeds_mock_test.go
+++ b/pkg/feeds/feeds_mock_test.go
@@ -6,7 +6,6 @@ package feeds
 
 import (
 	gomock "github.com/golang/mock/gomock"
-	podcast "github.com/mxpv/podcast"
 	model "github.com/mxpv/podsync/pkg/model"
 	reflect "reflect"
 	time "time"
@@ -36,12 +35,11 @@ func (m *MockBuilder) EXPECT() *MockBuilderMockRecorder {
 }
 
 // Build mocks base method
-func (m *MockBuilder) Build(feed *model.Feed) (*podcast.Podcast, error) {
+func (m *MockBuilder) Build(feed *model.Feed) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Build", feed)
-	ret0, _ := ret[0].(*podcast.Podcast)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
+	ret0, _ := ret[0].(error)
+	return ret0
 }
 
 // Build indicates an expected call of Build
@@ -50,21 +48,6 @@ func (mr *MockBuilderMockRecorder) Build(feed interface{}) *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Build", reflect.TypeOf((*MockBuilder)(nil).Build), feed)
 }
 
-// GetVideoCount mocks base method
-func (m *MockBuilder) GetVideoCount(feed *model.Feed) (uint64, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetVideoCount", feed)
-	ret0, _ := ret[0].(uint64)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetVideoCount indicates an expected call of GetVideoCount
-func (mr *MockBuilderMockRecorder) GetVideoCount(feed interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVideoCount", reflect.TypeOf((*MockBuilder)(nil).GetVideoCount), feed)
-}
-
 // Mockstorage is a mock of storage interface
 type Mockstorage struct {
 	ctrl     *gomock.Controller
@@ -117,6 +100,20 @@ func (mr *MockstorageMockRecorder) GetFeed(hashID interface{}) *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFeed", reflect.TypeOf((*Mockstorage)(nil).GetFeed), hashID)
 }
 
+// UpdateFeed mocks base method
+func (m *Mockstorage) UpdateFeed(feed *model.Feed) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateFeed", feed)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateFeed indicates an expected call of UpdateFeed
+func (mr *MockstorageMockRecorder) UpdateFeed(feed interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFeed", reflect.TypeOf((*Mockstorage)(nil).UpdateFeed), feed)
+}
+
 // GetMetadata mocks base method
 func (m *Mockstorage) GetMetadata(hashID string) (*model.Feed, error) {
 	m.ctrl.T.Helper()
@@ -199,68 +196,6 @@ func (mr *MockcacheServiceMockRecorder) Get(key interface{}) *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockcacheService)(nil).Get), key)
 }
 
-// SaveItem mocks base method
-func (m *MockcacheService) SaveItem(key string, item interface{}, exp time.Duration) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SaveItem", key, item, exp)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// SaveItem indicates an expected call of SaveItem
-func (mr *MockcacheServiceMockRecorder) SaveItem(key, item, exp interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveItem", reflect.TypeOf((*MockcacheService)(nil).SaveItem), key, item, exp)
-}
-
-// GetItem mocks base method
-func (m *MockcacheService) GetItem(key string, item interface{}) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetItem", key, item)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetItem indicates an expected call of GetItem
-func (mr *MockcacheServiceMockRecorder) GetItem(key, item interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItem", reflect.TypeOf((*MockcacheService)(nil).GetItem), key, item)
-}
-
-// SetMap mocks base method
-func (m *MockcacheService) SetMap(key string, fields map[string]interface{}, exp time.Duration) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetMap", key, fields, exp)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// SetMap indicates an expected call of SetMap
-func (mr *MockcacheServiceMockRecorder) SetMap(key, fields, exp interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMap", reflect.TypeOf((*MockcacheService)(nil).SetMap), key, fields, exp)
-}
-
-// GetMap mocks base method
-func (m *MockcacheService) GetMap(key string, fields ...string) (map[string]string, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{key}
-	for _, a := range fields {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetMap", varargs...)
-	ret0, _ := ret[0].(map[string]string)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetMap indicates an expected call of GetMap
-func (mr *MockcacheServiceMockRecorder) GetMap(key interface{}, fields ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{key}, fields...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMap", reflect.TypeOf((*MockcacheService)(nil).GetMap), varargs...)
-}
-
 // Invalidate mocks base method
 func (m *MockcacheService) Invalidate(key ...string) error {
 	m.ctrl.T.Helper()
diff --git a/pkg/feeds/feeds_test.go b/pkg/feeds/feeds_test.go
index 8f32017..225d918 100644
--- a/pkg/feeds/feeds_test.go
+++ b/pkg/feeds/feeds_test.go
@@ -3,7 +3,6 @@
 package feeds
 
 import (
-	"strconv"
 	"testing"
 	"time"
 
@@ -12,8 +11,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	itunes "github.com/mxpv/podcast"
-
 	"github.com/mxpv/podsync/pkg/api"
 	"github.com/mxpv/podsync/pkg/model"
 )
@@ -39,7 +36,7 @@ func TestService_CreateFeed(t *testing.T) {
 
 	s := Service{
 		generator: gen,
-		db:        db,
+		storage:   db,
 		builders:  map[api.Provider]Builder{api.ProviderYoutube: nil},
 	}
 
@@ -95,7 +92,7 @@ func TestService_QueryFeed(t *testing.T) {
 	db := NewMockstorage(ctrl)
 	db.EXPECT().GetFeed("123").Times(1).Return(nil, nil)
 
-	s := Service{db: db}
+	s := Service{storage: db}
 	_, err := s.QueryFeed("123")
 	require.NoError(t, err)
 }
@@ -104,97 +101,32 @@ func TestService_GetFromCache(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 
-	item := map[string]string{
-		updatedAtKey: strconv.FormatInt(time.Now().UTC().Unix(), 10),
-		feedKey: "test",
-	}
-
 	cache := NewMockcacheService(ctrl)
-	cache.EXPECT().GetMap("123", feedKey, updatedAtKey, videoCountKey).Return(item, nil)
+	cache.EXPECT().Get("123").Return("test", nil)
 
-	s := Service{cache: cache}
+	s := &Service{cache: cache}
 
 	data, err := s.BuildFeed("123")
 	assert.NoError(t, err)
 	assert.Equal(t, []byte("test"), data)
 }
 
-func TestService_VerifyCache(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-
-	cache := NewMockcacheService(ctrl)
-	cache.EXPECT().GetMap("123", feedKey, updatedAtKey, videoCountKey).Return(map[string]string{
-		feedKey: "test",
-		updatedAtKey: strconv.FormatInt(time.Now().UTC().Add(-20 * time.Minute).Unix(), 10),
-		videoCountKey: "30",
-	}, nil)
-
-	cache.EXPECT().SetMap("123", gomock.Any(), 15*24*time.Hour).Times(1).Return(nil)
-
-	stor := NewMockstorage(ctrl)
-	stor.EXPECT().GetFeed(feed.HashID).Times(1).Return(feed, nil)
-
-	builder := NewMockBuilder(ctrl)
-	builder.EXPECT().GetVideoCount(feed).Return(uint64(30), nil)
-
-	s := Service{db: stor, cache: cache, builders: map[api.Provider]Builder{
-		api.ProviderVimeo: builder,
-	}}
-
-	data, err := s.BuildFeed(feed.HashID)
-	assert.NoError(t, err)
-	assert.Equal(t, []byte("test"), data)
-}
-
 func TestService_BuildFeed(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 
 	stor := NewMockstorage(ctrl)
 	stor.EXPECT().GetFeed(feed.HashID).Times(1).Return(feed, nil)
+	stor.EXPECT().UpdateFeed(feed).Return(nil)
 
 	cache := NewMockcacheService(ctrl)
-	cache.EXPECT().GetMap(feed.HashID, feedKey, updatedAtKey, videoCountKey).Return(nil, errors.New("not found"))
-	cache.EXPECT().SetMap(feed.HashID, gomock.Any(), gomock.Any()).Return(nil)
-
-	podcast := itunes.New("", "", "", nil, nil)
+	cache.EXPECT().Get(feed.HashID).Return("", errors.New("not found"))
+	cache.EXPECT().Set(feed.HashID, gomock.Any(), 15*time.Minute).Return(nil)
 
 	builder := NewMockBuilder(ctrl)
-	builder.EXPECT().Build(feed).Return(&podcast, nil)
-	builder.EXPECT().GetVideoCount(feed).Return(uint64(25), nil)
+	builder.EXPECT().Build(feed).Return(nil)
 
-	s := Service{db: stor, cache: cache, builders: map[api.Provider]Builder{
-		api.ProviderVimeo: builder,
-	}}
-
-	_, err := s.BuildFeed(feed.HashID)
-	require.NoError(t, err)
-}
-
-func TestService_RebuildCache(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-
-	stor := NewMockstorage(ctrl)
-	stor.EXPECT().GetFeed(feed.HashID).Times(1).Return(feed, nil)
-
-	cache := NewMockcacheService(ctrl)
-	cache.EXPECT().GetMap("123", feedKey, updatedAtKey, videoCountKey).Return(map[string]string{
-		feedKey: "test",
-		updatedAtKey: strconv.FormatInt(time.Now().UTC().Add(-20 * time.Minute).Unix(), 10),
-		videoCountKey: "30",
-	}, nil)
-
-	cache.EXPECT().SetMap(feed.HashID, gomock.Any(), gomock.Any()).Return(nil)
-
-	podcast := itunes.New("", "", "", nil, nil)
-
-	builder := NewMockBuilder(ctrl)
-	builder.EXPECT().Build(feed).Return(&podcast, nil)
-	builder.EXPECT().GetVideoCount(feed).Return(uint64(25), nil)
-
-	s := Service{db: stor, cache: cache, builders: map[api.Provider]Builder{
+	s := Service{storage: stor, cache: cache, builders: map[api.Provider]Builder{
 		api.ProviderVimeo: builder,
 	}}
 
@@ -207,12 +139,12 @@ func TestService_WrongID(t *testing.T) {
 	defer ctrl.Finish()
 
 	cache := NewMockcacheService(ctrl)
-	cache.EXPECT().GetMap(gomock.Any(), feedKey, updatedAtKey, videoCountKey).Return(nil, errors.New("not found"))
+	cache.EXPECT().Get(gomock.Any()).Return("", errors.New("not found"))
 
 	stor := NewMockstorage(ctrl)
 	stor.EXPECT().GetFeed(gomock.Any()).Times(1).Return(nil, errors.New("not found"))
 
-	s := Service{db: stor, cache: cache}
+	s := &Service{storage: stor, cache: cache}
 
 	_, err := s.BuildFeed("invalid_feed_id")
 	require.Error(t, err)
@@ -225,7 +157,7 @@ func TestService_GetMetadata(t *testing.T) {
 	stor := NewMockstorage(ctrl)
 	stor.EXPECT().GetMetadata(feed.HashID).Times(1).Return(feed, nil)
 
-	s := Service{db: stor}
+	s := &Service{storage: stor}
 
 	m, err := s.GetMetadata(feed.HashID)
 	require.NoError(t, err)
diff --git a/pkg/model/model.go b/pkg/model/model.go
index 44d2690..7dc6ada 100644
--- a/pkg/model/model.go
+++ b/pkg/model/model.go
@@ -18,6 +18,19 @@ type Pledge struct {
 	IsPaused                      bool
 }
 
+type Item struct {
+	ID          string
+	Title       string
+	Description string
+	Thumbnail   string
+	Duration    int64
+	VideoURL    string
+	PubDate     time.Time `dynamodbav:",unixtime"`
+	Size        int64
+
+	Order string `dynamodbav:"-"`
+}
+
 //noinspection SpellCheckingInspection
 type Feed struct {
 	FeedID         int64  `sql:",pk" dynamodbav:"-"`
@@ -36,4 +49,12 @@ type Feed struct {
 	CoverArt       string    `dynamodbav:",omitempty"`
 	Explicit       bool
 	Language       string `dynamodbav:",omitempty"` // ISO 639
+	Title          string
+	Description    string
+	PubDate        time.Time `dynamodbav:",unixtime"`
+	Author         string
+	ItemURL        string    // Platform specific URL
+	Episodes       []*Item   // Array of episodes
+	LastID         string    // Last seen video URL ID (for incremental updater)
+	UpdatedAt      time.Time `dynamodbav:",unixtime"`
 }
diff --git a/pkg/storage/dynamo.go b/pkg/storage/dynamo.go
index cff6bf1..87fb503 100644
--- a/pkg/storage/dynamo.go
+++ b/pkg/storage/dynamo.go
@@ -191,6 +191,42 @@ func (d Dynamo) GetFeed(hashID string) (*model.Feed, error) {
 	return &feed, nil
 }
 
+func (d Dynamo) UpdateFeed(feed *model.Feed) error {
+	var (
+		pubDate   = strconv.FormatInt(feed.PubDate.Unix(), 10)
+		updatedAt = strconv.FormatInt(feed.LastAccess.Unix(), 10)
+	)
+
+	update := expr.
+		Set(expr.Name("Title"), expr.Value(feed.Title)).
+		Set(expr.Name("Description"), expr.Value(feed.Description)).
+		Set(expr.Name("PubDate"), expr.Value(pubDate)).
+		Set(expr.Name("Author"), expr.Value(feed.Author)).
+		Set(expr.Name("ItemURL"), expr.Value(feed.ItemURL)).
+		Set(expr.Name("Episodes"), expr.Value(feed.Episodes)).
+		Set(expr.Name("LastID"), expr.Value(feed.LastID)).
+		Set(expr.Name("UpdatedAt"), expr.Value(updatedAt))
+
+	expression, err := expr.NewBuilder().WithUpdate(update).Build()
+	if err != nil {
+		return err
+	}
+
+	input := &dynamodb.UpdateItemInput{
+		TableName: d.FeedsTableName,
+		Key: map[string]*dynamodb.AttributeValue{
+			"HashID": {S: aws.String(feed.HashID)},
+		},
+
+		UpdateExpression:          expression.Update(),
+		ExpressionAttributeNames:  expression.Names(),
+		ExpressionAttributeValues: expression.Values(),
+	}
+
+	_, err = d.dynamo.UpdateItem(input)
+	return err
+}
+
 func (d Dynamo) GetMetadata(hashID string) (*model.Feed, error) {
 	logger := log.WithField("hash_id", hashID)
 
@@ -308,7 +344,8 @@ func (d Dynamo) Downgrade(userID string, featureLevel int) ([]string, error) {
 			NewBuilder().
 			WithUpdate(expr.
 				Set(expr.Name("PageSize"), expr.Value(150)).
-				Set(expr.Name("FeatureLevel"), expr.Value(api.ExtendedFeatures))).
+				Set(expr.Name("FeatureLevel"), expr.Value(api.ExtendedFeatures)).
+				Set(expr.Name("LastID"), expr.Value(""))).
 			WithCondition(expr.
 				Name("PageSize").GreaterThan(expr.Value(150))).
 			Build()
@@ -345,7 +382,8 @@ func (d Dynamo) Downgrade(userID string, featureLevel int) ([]string, error) {
 				Set(expr.Name("PageSize"), expr.Value(50)).
 				Set(expr.Name("FeatureLevel"), expr.Value(api.DefaultFeatures)).
 				Set(expr.Name("Format"), expr.Value(api.FormatVideo)).
-				Set(expr.Name("Quality"), expr.Value(api.QualityHigh))).
+				Set(expr.Name("Quality"), expr.Value(api.QualityHigh)).
+				Set(expr.Name("LastID"), expr.Value(""))).
 			Build()
 
 		if err != nil {
diff --git a/pkg/storage/dynamo_test.go b/pkg/storage/dynamo_test.go
index 5814d1b..40708c8 100644
--- a/pkg/storage/dynamo_test.go
+++ b/pkg/storage/dynamo_test.go
@@ -5,16 +5,43 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/dynamodb"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
+	"github.com/mxpv/podsync/pkg/api"
+	"github.com/mxpv/podsync/pkg/model"
 )
 
+var feed = &model.Feed{
+	HashID:   "123",
+	ItemID:   "xyz",
+	Provider: api.ProviderVimeo,
+	LinkType: api.LinkTypeChannel,
+	PageSize: 50,
+	Quality:  api.QualityHigh,
+	Format:   api.FormatVideo,
+}
+
 func TestDynamo(t *testing.T) {
-	runStorageTests(t, createDynamo)
+	runStorageTests(t, func(t *testing.T) storage {
+		return createDynamo(t)
+	})
+}
+
+func TestDynamo_UpdateFeed(t *testing.T) {
+	client := createDynamo(t)
+	defer client.Close()
+
+	err := client.SaveFeed(feed)
+	assert.NoError(t, err)
+
+	err = client.UpdateFeed(feed)
+	assert.NoError(t, err)
 }
 
 // docker run -it --rm -p 8000:8000 amazon/dynamodb-local
 // noinspection ALL
-func createDynamo(t *testing.T) storage {
+func createDynamo(t *testing.T) Dynamo {
 	d, err := NewDynamo(&aws.Config{
 		Region:   aws.String("us-east-1"),
 		Endpoint: aws.String("http://localhost:8000/"),
diff --git a/pkg/storage/pg_test.go b/pkg/storage/pg_test.go
index 42b3a3a..42a9e5d 100644
--- a/pkg/storage/pg_test.go
+++ b/pkg/storage/pg_test.go
@@ -30,7 +30,9 @@ func TestPostgres_UpdateLastAccess(t *testing.T) {
 
 func TestPostgres(t *testing.T) {
 	runStorageTests(t, func(t *testing.T) storage {
-		return createPG(t)
+		t.Skip()
+		return nil
+		//return createPG(t)
 	})
 }
 
diff --git a/pkg/storage/storage_test.go b/pkg/storage/storage_test.go
index 6c9d1a9..3ff719d 100644
--- a/pkg/storage/storage_test.go
+++ b/pkg/storage/storage_test.go
@@ -15,7 +15,7 @@ type storage interface {
 	SaveFeed(feed *model.Feed) error
 	GetFeed(hashID string) (*model.Feed, error)
 	GetMetadata(hashID string) (*model.Feed, error)
-	Downgrade(userID string, featureLevel int) error
+	Downgrade(userID string, featureLevel int) ([]string, error)
 
 	// Patreon pledges
 	AddPledge(pledge *model.Pledge) error
@@ -133,7 +133,7 @@ func testDowngradeToDefaultFeatures(t *testing.T, storage storage) {
 	err := storage.SaveFeed(testDowngradePledge)
 	require.NoError(t, err)
 
-	err = storage.Downgrade(testDowngradePledge.UserID, api.DefaultFeatures)
+	_, err = storage.Downgrade(testDowngradePledge.UserID, api.DefaultFeatures)
 	require.NoError(t, err)
 
 	downgraded, err := storage.GetFeed(testDowngradePledge.HashID)
@@ -149,7 +149,7 @@ func testDowngradeToExtendedFeatures(t *testing.T, storage storage) {
 	err := storage.SaveFeed(testDowngradePledge)
 	require.NoError(t, err)
 
-	err = storage.Downgrade(testDowngradePledge.UserID, api.ExtendedFeatures)
+	_, err = storage.Downgrade(testDowngradePledge.UserID, api.ExtendedFeatures)
 	require.NoError(t, err)
 
 	downgraded, err := storage.GetFeed(testDowngradePledge.HashID)