diff --git a/build.gradle b/build.gradle
index 32668dc..e11bddf 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,6 +1,6 @@
 plugins {
-    id 'org.springframework.boot' version '2.7.1'
-    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
+    id 'org.springframework.boot' version '2.7.2'
+    id 'io.spring.dependency-management' version '1.0.12.RELEASE'
     id 'java'
 }
 
@@ -20,17 +20,19 @@ repositories {
 }
 
 dependencies {
-    implementation 'org.springframework.boot:spring-boot-starter-webflux:2.7.1'
-    implementation 'org.springframework.boot:spring-boot-configuration-processor:2.7.1'
-    implementation 'org.springframework.boot:spring-boot-starter-validation:2.7.1'
-    implementation 'org.springframework.boot:spring-boot-starter-data-mongodb-reactive:2.7.1'
-    runtimeOnly 'org.springframework.boot:spring-boot-devtools:2.7.1'
+    implementation 'org.springframework.boot:spring-boot-starter-webflux'
+    implementation 'org.springframework.boot:spring-boot-configuration-processor'
+    implementation 'org.springframework.boot:spring-boot-starter-validation'
+    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
+    runtimeOnly 'org.postgresql:postgresql'
+    runtimeOnly 'org.springframework.boot:spring-boot-devtools'
     compileOnly 'org.projectlombok:lombok'
     annotationProcessor 'org.projectlombok:lombok'
-    testImplementation 'org.springframework.boot:spring-boot-starter-test:2.7.1'
-    testImplementation 'io.projectreactor:reactor-test:3.4.19'
+    testImplementation 'org.springframework.boot:spring-boot-starter-test'
+    testImplementation 'io.projectreactor:reactor-test'
+    runtimeOnly 'com.h2database:h2'
 }
 
 tasks.named('test') {
   useJUnitPlatform()
-}
+}
\ No newline at end of file
diff --git a/src/main/java/com/kikawet/reactiveMediaServer/beans/SchedulerBean.java b/src/main/java/com/kikawet/reactiveMediaServer/beans/SchedulerBean.java
new file mode 100644
index 0000000..d17b807
--- /dev/null
+++ b/src/main/java/com/kikawet/reactiveMediaServer/beans/SchedulerBean.java
@@ -0,0 +1,18 @@
+package com.kikawet.reactiveMediaServer.beans;
+
+import java.util.concurrent.Executors;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import reactor.core.scheduler.Scheduler;
+import reactor.core.scheduler.Schedulers;
+
+@Configuration
+public class SchedulerBean {	
+	@Bean
+    Scheduler jdbcScheduler(@Value("${spring.task.scheduling.pool.size}") int maxThreads) {
+        return Schedulers.fromExecutor(Executors.newFixedThreadPool(maxThreads));
+    }
+}
diff --git a/src/main/java/com/kikawet/reactiveMediaServer/beans/StartUp.java b/src/main/java/com/kikawet/reactiveMediaServer/beans/StartUp.java
index 38e7855..08c5383 100644
--- a/src/main/java/com/kikawet/reactiveMediaServer/beans/StartUp.java
+++ b/src/main/java/com/kikawet/reactiveMediaServer/beans/StartUp.java
@@ -3,41 +3,58 @@
 import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Set;
 
 import javax.annotation.PostConstruct;
 
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Profile;
+import org.springframework.core.env.Environment;
 import org.springframework.stereotype.Component;
 
 import com.kikawet.reactiveMediaServer.model.User;
 import com.kikawet.reactiveMediaServer.model.Video;
 import com.kikawet.reactiveMediaServer.model.WatchedVideo;
 import com.kikawet.reactiveMediaServer.repository.UserRepository;
-import com.kikawet.reactiveMediaServer.repository.VideoRepository;
+import com.kikawet.reactiveMediaServer.service.VideoService;
 
 @Component
+@Profile("!test")
 public class StartUp {
+	// TODO: remove this class when the user repo is done and move everything to sql
+
+	@Autowired
+	Environment env;
 
 	@Autowired
 	private UserRepository users;
 
 	@Autowired
-	private VideoRepository videos;
+	private VideoService videos;
 
 	@PostConstruct
 	void setUp() {
 		User u = new User();
-		Video v = new Video(":D");
+		Video v = this.videos.createVideo(":D").block();
 
 		u.setLogin("tom");
 
+		u.setAvailableVideos(Set.of(v));
+
 		u.setHistory(new ArrayList<>(
 				Arrays.asList(
 						new WatchedVideo(u, v, LocalDateTime.now(), 17),
 						new WatchedVideo(u, v, LocalDateTime.now(), 69),
 						new WatchedVideo(u, v, LocalDateTime.now(), 33))));
 
-		this.users.put(u.getLogin(), u);
-		this.videos.put(v.getTitle(), v);
+		this.users.save(u);
+
+		User user = this.users.findByLogin(u.getLogin());
+		if (user == null) {
+			this.users.save(u);	
+		}
+
+		System.out.println("Saved user " + user.getLogin());
+		System.out.println("Saved video " + v.getTitle());
 	}
 }
diff --git a/src/main/java/com/kikawet/reactiveMediaServer/model/User.java b/src/main/java/com/kikawet/reactiveMediaServer/model/User.java
index e706274..db3e943 100644
--- a/src/main/java/com/kikawet/reactiveMediaServer/model/User.java
+++ b/src/main/java/com/kikawet/reactiveMediaServer/model/User.java
@@ -1,25 +1,43 @@
 package com.kikawet.reactiveMediaServer.model;
 
 import java.util.ArrayList;
-import java.util.Collection;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.stream.Stream;
 
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.OneToMany;
+import javax.persistence.Table;
+import javax.persistence.Transient;
+
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
 import lombok.Setter;
 
 @Getter
 @Setter
 @AllArgsConstructor
 @NoArgsConstructor
+@RequiredArgsConstructor
+@Entity
+@Table(name = "USERS") // User is a keyword so can't create a table with that name
 public class User {
+	@Id
+	@NonNull
 	String login;
-	List<Video> availableVideos = new ArrayList<>();
+
+	@OneToMany
+	Set<Video> availableVideos = new HashSet<>();
+
+	@Transient
 	List<WatchedVideo> history = new ArrayList<>();
 
-	public Stream<Video> getVideos() {
+	public Stream<Video> getAvailableVideos() {
 		return availableVideos.stream();
 	}
 
@@ -27,7 +45,10 @@ public Stream<WatchedVideo> getHistory() {
 		return history.stream();
 	}
 
-	public boolean appendHistory(Collection<WatchedVideo> history) {
-		return this.history.addAll(history);
+	public boolean addWatchVideo(WatchedVideo wv) {
+		if (!availableVideos.contains(wv.video))
+			return false;
+
+		return this.history.add(wv);
 	}
 }
diff --git a/src/main/java/com/kikawet/reactiveMediaServer/model/Video.java b/src/main/java/com/kikawet/reactiveMediaServer/model/Video.java
index 5b0cab5..802e6b1 100644
--- a/src/main/java/com/kikawet/reactiveMediaServer/model/Video.java
+++ b/src/main/java/com/kikawet/reactiveMediaServer/model/Video.java
@@ -1,10 +1,19 @@
 package com.kikawet.reactiveMediaServer.model;
 
+import javax.persistence.Entity;
+import javax.persistence.Id;
+
 import lombok.AllArgsConstructor;
 import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.NonNull;
 
 @AllArgsConstructor
 @Getter
+@Entity
+@NoArgsConstructor
 public class Video {
+	@Id
+	@NonNull
 	String title;
 }
diff --git a/src/main/java/com/kikawet/reactiveMediaServer/repository/UserRepository.java b/src/main/java/com/kikawet/reactiveMediaServer/repository/UserRepository.java
index 13bd7fd..69110e0 100644
--- a/src/main/java/com/kikawet/reactiveMediaServer/repository/UserRepository.java
+++ b/src/main/java/com/kikawet/reactiveMediaServer/repository/UserRepository.java
@@ -1,25 +1,11 @@
 package com.kikawet.reactiveMediaServer.repository;
 
-import java.util.HashMap;
-import java.util.Map;
-
+import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 
 import com.kikawet.reactiveMediaServer.model.User;
 
 @Repository
-public class UserRepository {
-	private static final Map<String, User> users = new HashMap<>();
-
-	public User findById(String login) {
-		return users.get(login);
-	}
-
-	public void updateUser(User u) {
-		users.put(u.getLogin(), u);
-	}
-
-	public void put(String login, User u) {
-		users.put(login, u);
-	}
+public interface UserRepository extends JpaRepository<User, Long>{
+	User findByLogin(String login);
 }
diff --git a/src/main/java/com/kikawet/reactiveMediaServer/repository/VideoRepository.java b/src/main/java/com/kikawet/reactiveMediaServer/repository/VideoRepository.java
index 588b96a..a8792a0 100644
--- a/src/main/java/com/kikawet/reactiveMediaServer/repository/VideoRepository.java
+++ b/src/main/java/com/kikawet/reactiveMediaServer/repository/VideoRepository.java
@@ -1,21 +1,11 @@
 package com.kikawet.reactiveMediaServer.repository;
 
-import java.util.HashMap;
-import java.util.Map;
-
+import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 
 import com.kikawet.reactiveMediaServer.model.Video;
 
 @Repository
-public class VideoRepository {
-	private static final Map<String, Video> videos = new HashMap<>();
-
-	public Video findVideoByTitle(String title) {
-		return videos.get(title);
-	}
-
-	public void put(String title, Video video) {
-		videos.put(title, video);
-	}
+public interface VideoRepository extends JpaRepository<Video, Long> {
+	Video findByTitle(String title);
 }
diff --git a/src/main/java/com/kikawet/reactiveMediaServer/routes/UserRouter.java b/src/main/java/com/kikawet/reactiveMediaServer/routes/UserRouter.java
index fe19def..1dc1961 100644
--- a/src/main/java/com/kikawet/reactiveMediaServer/routes/UserRouter.java
+++ b/src/main/java/com/kikawet/reactiveMediaServer/routes/UserRouter.java
@@ -3,12 +3,11 @@
 import static org.springframework.web.reactive.function.server.RequestPredicates.GET;
 import static org.springframework.web.reactive.function.server.RequestPredicates.POST;
 import static org.springframework.web.reactive.function.server.RouterFunctions.route;
-import static org.springframework.web.reactive.function.server.ServerResponse.ok;
 import static org.springframework.web.reactive.function.server.ServerResponse.badRequest;
+import static org.springframework.web.reactive.function.server.ServerResponse.ok;
 import static org.springframework.web.reactive.function.server.ServerResponse.status;
-import static reactor.core.publisher.Flux.fromStream;
 
-import java.util.stream.Stream;
+import java.util.List;
 
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Bean;
@@ -22,13 +21,13 @@
 import org.springframework.web.server.ResponseStatusException;
 
 import com.kikawet.reactiveMediaServer.beans.PageableMapper;
-import com.kikawet.reactiveMediaServer.dto.WatchedVideoDTO;
 import com.kikawet.reactiveMediaServer.exception.ResourceNotFoundException;
 import com.kikawet.reactiveMediaServer.exception.UnauthorizedUserException;
 import com.kikawet.reactiveMediaServer.model.WatchedVideo;
 import com.kikawet.reactiveMediaServer.service.UserService;
 import com.kikawet.reactiveMediaServer.validation.WatcherVideoDTOValidationHandler;
 
+import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 @Configuration
@@ -47,13 +46,18 @@ RouterFunction<ServerResponse> getHistoryByLogin() {
 		return route(GET("/user/{login}/history"), this::getHistoryByLoginHandler);
 	}
 
+	@Bean
+	RouterFunction<ServerResponse> getAvailableVideosByLogin() {
+		return route(GET("/user/{login}/videos"), this::getAvailableVideosByLoginHandler);
+	}
+
 	@Bean
 	RouterFunction<ServerResponse> updateHistoryByLogin() {
 		return route(POST("/user/{login}/watch"), this::updateHistoryByLoginHandler)
 				.and(route(POST("/user/{login}/history"), this::updateHistoryByLoginHandler));
 	}
 
-	public Mono<ServerResponse> updateHistoryByLoginHandler(ServerRequest serverRequest) {
+	public Mono<ServerResponse> updateHistoryByLoginHandler(final ServerRequest serverRequest) {
 		final String login = serverRequest.pathVariable("login");
 
 		return watcherValidationHandler.requireValidBodyList(serverRequest,
@@ -61,34 +65,41 @@ public Mono<ServerResponse> updateHistoryByLoginHandler(ServerRequest serverRequ
 					if (newWatches.isEmpty())
 						return ok().build();
 
-					try {
-						boolean success = users.updateHistoryByLogin(login, newWatches);
+					return users.updateHistoryByLogin(login, newWatches)
+							.flatMap(success -> {
+								if (success)
+									return status(HttpStatus.CREATED).build();
+								return badRequest().build();
+							})
+							.onErrorResume(UnauthorizedUserException.class,
+									e -> status(HttpStatus.UNAUTHORIZED).build())
+							.doOnError(ResourceNotFoundException.class, e -> {
+								throw new ResponseStatusException(HttpStatus.BAD_REQUEST, e.getMessage(), e);
+							});
 
-						if (success)
-							return status(HttpStatus.CREATED).build();
+				});
+	}
 
-						return badRequest().build();
+	public Mono<ServerResponse> getHistoryByLoginHandler(final ServerRequest serverRequest) {
+		final String login = serverRequest.pathVariable("login");
+		final Pageable page = pm.getPageable(serverRequest);
 
-					} catch (UnauthorizedUserException e) {
-						return status(HttpStatus.UNAUTHORIZED).build();
-					} catch (ResourceNotFoundException e) {
-						throw new ResponseStatusException(HttpStatus.BAD_REQUEST, e.getMessage(), e);
-					}
-				});
+		return fluxToResponse(users.getHistoryByLogin(login, page)
+				.map(WatchedVideo::toDTO));
 	}
 
-	public Mono<ServerResponse> getHistoryByLoginHandler(ServerRequest serverRequest) {
+	public Mono<ServerResponse> getAvailableVideosByLoginHandler(final ServerRequest serverRequest) {
 		final String login = serverRequest.pathVariable("login");
 		final Pageable page = pm.getPageable(serverRequest);
 
-		try {
-			Stream<WatchedVideoDTO> history = users.getHistoryByLogin(login, page).map(WatchedVideo::toDTO);
+		return fluxToResponse(users.getAvailableVideosByLogin(login, page));
+	}
 
-			return ok()
-					.contentType(MediaType.APPLICATION_JSON)
-					.body(fromStream(history), WatchedVideoDTO.class);
-		} catch (UnauthorizedUserException e) {
-			return status(HttpStatus.UNAUTHORIZED).build();
-		}
+	private Mono<ServerResponse> fluxToResponse(Flux<?> objects) {
+		return objects.collectList()
+				.flatMap(items -> ok()
+						.contentType(MediaType.APPLICATION_JSON)
+						.body(Mono.just(items), List.class))
+				.onErrorResume(UnauthorizedUserException.class, e -> status(HttpStatus.UNAUTHORIZED).build());
 	}
 }
diff --git a/src/main/java/com/kikawet/reactiveMediaServer/routes/VideoRouter.java b/src/main/java/com/kikawet/reactiveMediaServer/routes/VideoRouter.java
index e264e09..0726f81 100644
--- a/src/main/java/com/kikawet/reactiveMediaServer/routes/VideoRouter.java
+++ b/src/main/java/com/kikawet/reactiveMediaServer/routes/VideoRouter.java
@@ -1,9 +1,11 @@
 package com.kikawet.reactiveMediaServer.routes;
 
 import static org.springframework.web.reactive.function.server.RequestPredicates.GET;
+import static org.springframework.web.reactive.function.server.RequestPredicates.POST;
 import static org.springframework.web.reactive.function.server.RouterFunctions.route;
 import static org.springframework.web.reactive.function.server.ServerResponse.notFound;
 import static org.springframework.web.reactive.function.server.ServerResponse.ok;
+import static org.springframework.web.reactive.function.server.ServerResponse.status;
 
 import java.util.List;
 
@@ -11,6 +13,7 @@
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.io.Resource;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.util.MimeType;
 import org.springframework.util.StringUtils;
@@ -20,9 +23,9 @@
 
 import com.kikawet.reactiveMediaServer.beans.PageableMapper;
 import com.kikawet.reactiveMediaServer.exception.ResourceNotFoundException;
+import com.kikawet.reactiveMediaServer.model.Video;
 import com.kikawet.reactiveMediaServer.service.VideoService;
 
-import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 @Configuration
@@ -37,11 +40,7 @@ public class VideoRouter {
 	@Bean
 	RouterFunction<ServerResponse> findAllVideoTitleRoute() {
 		return route(GET("/video"), req -> ok()
-				.body(
-						Flux.fromStream(
-								videos.findAllVideoTitle(
-										pm.getPageable(req)))
-								.collectList(),
+				.body(videos.findAllVideoTitle(pm.getPageable(req)).collectList(),
 						List.class));
 	}
 
@@ -50,7 +49,17 @@ RouterFunction<ServerResponse> findVideoByNameRoute() {
 		return route(GET("/video/{name}"), this::findVideoByNameHandler);
 	}
 
-	public Mono<ServerResponse> findVideoByNameHandler(ServerRequest serverRequest) {
+	@Bean
+	RouterFunction<ServerResponse> createVideo() {
+		return route(POST("/video/{name}"), req -> {
+			return status(HttpStatus.CREATED)
+					.body(
+							videos.createVideo(req.pathVariable("name")),
+							Video.class);
+		});
+	}
+
+	public Mono<ServerResponse> findVideoByNameHandler(final ServerRequest serverRequest) {
 		final String name = serverRequest.pathVariable("name");
 
 		try {
@@ -60,7 +69,7 @@ public Mono<ServerResponse> findVideoByNameHandler(ServerRequest serverRequest)
 			return ok()
 					.contentType(MediaType.asMediaType(MimeType.valueOf("video/" + mimeType)))
 					.body(Mono.just(video), Resource.class);
-		} catch (ResourceNotFoundException rnfe) {
+		} catch (final ResourceNotFoundException rnfe) {
 			return notFound().build();
 		}
 	}
diff --git a/src/main/java/com/kikawet/reactiveMediaServer/service/UserService.java b/src/main/java/com/kikawet/reactiveMediaServer/service/UserService.java
index 93436bf..063d5d9 100644
--- a/src/main/java/com/kikawet/reactiveMediaServer/service/UserService.java
+++ b/src/main/java/com/kikawet/reactiveMediaServer/service/UserService.java
@@ -1,8 +1,6 @@
 package com.kikawet.reactiveMediaServer.service;
 
 import java.util.Collection;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.Pageable;
@@ -12,9 +10,14 @@
 import com.kikawet.reactiveMediaServer.dto.WatchedVideoDTO;
 import com.kikawet.reactiveMediaServer.exception.UnauthorizedUserException;
 import com.kikawet.reactiveMediaServer.model.User;
+import com.kikawet.reactiveMediaServer.model.Video;
 import com.kikawet.reactiveMediaServer.model.WatchedVideo;
 import com.kikawet.reactiveMediaServer.repository.UserRepository;
 
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.core.scheduler.Scheduler;
+
 @Service
 public class UserService {
 
@@ -24,41 +27,57 @@ public class UserService {
 	@Autowired
 	private VideoService videoService;
 
-	public Stream<WatchedVideo> getHistoryByLogin(String login) {
+	@Autowired
+	private Scheduler scheduler;
+
+	public Flux<WatchedVideo> getHistoryByLogin(final String login) {
 		return this.getHistoryByLogin(login, PageableMapper.DEFAULT_PAGE_REQUEST);
 	}
 
-	public Stream<WatchedVideo> getHistoryByLogin(String login, Pageable page) {
-		User user = validateLogin(login);
-		return user.getHistory()
-				.skip(page.getOffset())
-				.limit(page.getPageSize());
+	public Flux<WatchedVideo> getHistoryByLogin(final String login, final Pageable page) {
+		return validateLogin(login)
+				.map(user -> user.getHistory()
+						.skip(page.getOffset())
+						.limit(page.getPageSize()))
+				.flatMapMany(Flux::fromStream);
 	}
 
-	public boolean updateHistoryByLogin(String login, Collection<WatchedVideoDTO> newWatches) {
-		User user = validateLogin(login);
+	public Flux<Video> getAvailableVideosByLogin(final String login) {
+		return this.getAvailableVideosByLogin(login, PageableMapper.DEFAULT_PAGE_REQUEST);
+	}
 
-		boolean result = user.appendHistory(newWatches.stream().map(dto -> {
-			WatchedVideo wv = new WatchedVideo();
+	
+	public Flux<Video> getAvailableVideosByLogin(final String login, final Pageable page) {
+		return validateLogin(login)
+				.map(user -> user.getAvailableVideos()
+						.skip(page.getOffset())
+						.limit(page.getPageSize()))
+				.flatMapMany(Flux::fromStream);
+	}
 
-			wv.setUser(user);
-			wv.setVideo(videoService.findVideoByTitle(dto.getTitle()));
-			wv.setTime(dto.getTime());
-			wv.setCompletionPercentage(dto.getCompletionPercentage());
+	public Mono<Boolean> updateHistoryByLogin(final String login, final Collection<WatchedVideoDTO> newWatches) {
+		return validateLogin(login).flatMap(user ->
 
-			return wv;
-		}).collect(Collectors.toList()));
+		Flux.concat(newWatches.stream().map(dto -> {
+			return videoService.findVideoByTitle(dto.getTitle()).map(video -> {
+				final WatchedVideo wv = new WatchedVideo();
 
-		return result;
-	}
+				wv.setUser(user);
+				wv.setVideo(video);
+				wv.setTime(dto.getTime());
+				wv.setCompletionPercentage(dto.getCompletionPercentage());
 
-	private User validateLogin(String login) {
-		User u = users.findById(login);
+				return user.addWatchVideo(wv);
+			});
 
-		if (u == null) {
-			throw new UnauthorizedUserException();
-		}
+		}).toList())
+				.takeUntil(x -> !x)
+				.reduce(true, (accum, value) -> accum && value));
+	}
 
-		return u;
+	private Mono<User> validateLogin(final String login) {
+		return Mono.fromCallable(() -> users.findByLogin(login))
+				.publishOn(scheduler)
+				.switchIfEmpty(Mono.error(new UnauthorizedUserException()));
 	}
 }
diff --git a/src/main/java/com/kikawet/reactiveMediaServer/service/VideoService.java b/src/main/java/com/kikawet/reactiveMediaServer/service/VideoService.java
index 014514b..5c21e9e 100644
--- a/src/main/java/com/kikawet/reactiveMediaServer/service/VideoService.java
+++ b/src/main/java/com/kikawet/reactiveMediaServer/service/VideoService.java
@@ -4,7 +4,6 @@
 
 import java.nio.file.Path;
 import java.util.Optional;
-import java.util.stream.Stream;
 
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
@@ -19,6 +18,10 @@
 import com.kikawet.reactiveMediaServer.model.Video;
 import com.kikawet.reactiveMediaServer.repository.VideoRepository;
 
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.core.scheduler.Scheduler;
+
 @Service
 public class VideoService {
 
@@ -31,17 +34,16 @@ public class VideoService {
 	@Autowired
 	private VideoRepository videos;
 
-	public Video findVideoByTitle(String title) {
-		Video v = videos.findVideoByTitle(title);
-
-		if (v == null) {
-			throw new ResourceNotFoundException(title);
-		}
+	@Autowired
+	private Scheduler scheduler;
 
-		return v;
+	public Mono<Video> findVideoByTitle(final String title) {
+		return Mono.fromCallable(() -> videos.findByTitle(title))
+				.publishOn(scheduler)
+				.switchIfEmpty(Mono.error(new ResourceNotFoundException(title)));
 	}
 
-	public Resource findVideoByName(String fileName) {
+	public Resource findVideoByName(final String fileName) {
 		Optional<Path> videoPath = resourceLoader
 				.listFiles(videoBasePath)
 				.parallel()
@@ -56,16 +58,23 @@ public Resource findVideoByName(String fileName) {
 		return resourceLoader.getResource(videoPath.get().toString());
 	}
 
-	public Stream<String> findAllVideoTitle(final Pageable page) {
-		return resourceLoader.listFiles(videoBasePath)
+	public Flux<String> findAllVideoTitle(final Pageable page) {
+		return Flux.fromStream(resourceLoader.listFiles(videoBasePath)
 				.skip(page.getOffset())
 				.limit(page.getPageSize())
 				.map(Path::getFileName)
 				.map(Path::toString)
-				.map(StringUtils::stripFilenameExtension);
+				.map(StringUtils::stripFilenameExtension));
 	}
 
-	public Stream<String> findAllVideoTitle() {
+	public Flux<String> findAllVideoTitle() {
 		return this.findAllVideoTitle(PageableMapper.DEFAULT_PAGE_REQUEST);
 	}
+
+	public Mono<Video> createVideo(final String title) {
+		return this.findVideoByTitle(title)
+				.onErrorResume(e -> Mono.fromCallable(() -> this.videos.saveAndFlush(new Video(title))))
+				.publishOn(scheduler);
+
+	}
 }
diff --git a/src/main/resources/application.yml b/src/main/resources/application.yml
index 9c2c10b..5f79c51 100644
--- a/src/main/resources/application.yml
+++ b/src/main/resources/application.yml
@@ -1,6 +1,20 @@
 
 video:
     basePath: ${VIDEO_BASEPATH:unknown}
+
+spring:
+  datasource:
+    url: ${DBURL:jdbc:postgresql://localhost:5432/rmsDB}
+    username: ${DBUSR:rmsUser}
+    password: ${DBPWD:rmsPassword}
+  jpa:
+    open-in-view: false
+    show-sql: true
+    database-platform: org.hibernate.dialect.PostgreSQL9Dialect
+    hibernate:
+      ddl-auto: update
+  task.scheduling.pool.size: 3
+
 server:
   servlet:
     context-path: /
diff --git a/src/main/resources/setup-db.sh b/src/main/resources/setup-db.sh
new file mode 100644
index 0000000..faf8873
--- /dev/null
+++ b/src/main/resources/setup-db.sh
@@ -0,0 +1,11 @@
+#!/bin/bash
+
+DBPWD=${DBPWD:-rmsPassword}
+DBUSR=${DBUSR:-rmsUser}
+DBNAME=${DBNAME:-rmsDB}
+DBPORT=${DBPORT:-5432}
+
+docker run -p $DBPORT:$DBPORT --name rms-db -e POSTGRES_DB=$DBNAME -e POSTGRES_PASSWORD=$DBPWD -e POSTGRES_USER=$DBUSR -d postgres
+
+echo "Database created connect to the console and run:"
+echo "psql $DBNAME $DBUSR"
diff --git a/src/test/java/com/kikawet/reactiveMediaServer/routes/BaseRouterTests.java b/src/test/java/com/kikawet/reactiveMediaServer/routes/BaseRouterTests.java
index 34ff533..a2049b9 100644
--- a/src/test/java/com/kikawet/reactiveMediaServer/routes/BaseRouterTests.java
+++ b/src/test/java/com/kikawet/reactiveMediaServer/routes/BaseRouterTests.java
@@ -1,11 +1,16 @@
 package com.kikawet.reactiveMediaServer.routes;
 
+import java.time.Duration;
+
 import org.springframework.test.web.reactive.server.WebTestClient;
 import org.springframework.web.reactive.function.server.RouterFunction;
 
 public abstract class BaseRouterTests {
 
-	protected WebTestClient getWebTestClient(RouterFunction<?> route) {
-		return WebTestClient.bindToRouterFunction(route).build();
+	protected WebTestClient getWebTestClient(final RouterFunction<?> route) {
+		return WebTestClient.bindToRouterFunction(route)
+				.configureClient()
+				.responseTimeout(Duration.ofMinutes(1))
+				.build();
 	}
 }
diff --git a/src/test/java/com/kikawet/reactiveMediaServer/routes/UserRouterTests.java b/src/test/java/com/kikawet/reactiveMediaServer/routes/UserRouterTests.java
index 483ae6f..d4ecf8f 100644
--- a/src/test/java/com/kikawet/reactiveMediaServer/routes/UserRouterTests.java
+++ b/src/test/java/com/kikawet/reactiveMediaServer/routes/UserRouterTests.java
@@ -24,13 +24,15 @@
 import com.kikawet.reactiveMediaServer.model.WatchedVideo;
 import com.kikawet.reactiveMediaServer.service.UserService;
 
+import reactor.core.publisher.Flux;
+
 @SpringBootTest
 public class UserRouterTests extends BaseRouterTests {
 
 	@MockBean
 	UserService us;
 
-	private final User testUser = new User("test", null, null);
+	private final User testUser = new User("test");
 	private final Video testVideo = new Video("testVideo");
 	private final List<WatchedVideo> watchedVideos = List.of(
 			new WatchedVideo(testUser, testVideo, LocalDateTime.now(), 17),
@@ -39,12 +41,12 @@ public class UserRouterTests extends BaseRouterTests {
 
 	@BeforeEach
 	void setUp() {
-		when(us.getHistoryByLogin(anyString(), any())).thenThrow(UnauthorizedUserException.class);
-		when(us.getHistoryByLogin(eq("test"), any())).thenReturn(watchedVideos.stream());
+		when(us.getHistoryByLogin(anyString(), any())).thenReturn(Flux.error(new UnauthorizedUserException()));
+		when(us.getHistoryByLogin(eq("test"), any())).thenReturn(Flux.fromStream(watchedVideos.stream()));
 	}
 
 	@Test
-	void getHistoryByLoginTest(@Autowired RouterFunction<?> getHistoryByLogin) {
+	void getHistoryByLoginTest(@Autowired final RouterFunction<?> getHistoryByLogin) {
 		getWebTestClient(getHistoryByLogin)
 				.get()
 				.uri("/user/test/history")
@@ -61,7 +63,7 @@ void getHistoryByLoginTest(@Autowired RouterFunction<?> getHistoryByLogin) {
 	}
 
 	@Test
-	void getHistoryByLoginThrowsTest(@Autowired RouterFunction<?> getHistoryByLogin) {
+	void getHistoryByLoginThrowsTest(@Autowired final RouterFunction<?> getHistoryByLogin) {
 		getWebTestClient(getHistoryByLogin)
 				.get()
 				.uri("/user/null/history")
diff --git a/src/test/java/com/kikawet/reactiveMediaServer/routes/VideoRouterTests.java b/src/test/java/com/kikawet/reactiveMediaServer/routes/VideoRouterTests.java
index 828923a..d3fcc6a 100644
--- a/src/test/java/com/kikawet/reactiveMediaServer/routes/VideoRouterTests.java
+++ b/src/test/java/com/kikawet/reactiveMediaServer/routes/VideoRouterTests.java
@@ -22,6 +22,8 @@
 import com.kikawet.reactiveMediaServer.exception.ResourceNotFoundException;
 import com.kikawet.reactiveMediaServer.service.VideoService;
 
+import reactor.core.publisher.Flux;
+
 @SpringBootTest
 public class VideoRouterTests extends BaseRouterTests {
 
@@ -29,17 +31,17 @@ public class VideoRouterTests extends BaseRouterTests {
 	VideoService vs;
 
 	private final List<String> videosList = Arrays.asList("video1", "video2", "video3");
-	private final Resource mockVideo = new ClassPathResource("application.yml");
+	private final Resource mockVideo = new ClassPathResource("config/application.yml");
 
 	@BeforeEach
 	void setUp() {
-		when(vs.findAllVideoTitle(any())).thenReturn(videosList.stream());
+		when(vs.findAllVideoTitle(any())).thenReturn(Flux.fromStream(videosList.stream()));
 		when(vs.findVideoByName(anyString())).thenThrow(ResourceNotFoundException.class);
 		when(vs.findVideoByName(eq("mockVideo"))).thenReturn(mockVideo);
 	}
 
 	@Test
-	void findAllVideoTitleRouteTest(@Autowired RouterFunction<?> findAllVideoTitleRoute) {
+	void findAllVideoTitleRouteTest(@Autowired final RouterFunction<?> findAllVideoTitleRoute) {
 		getWebTestClient(findAllVideoTitleRoute)
 				.get()
 				.uri("/video")
@@ -53,7 +55,7 @@ void findAllVideoTitleRouteTest(@Autowired RouterFunction<?> findAllVideoTitleRo
 	}
 
 	@Test
-	void findVideoByNameRouteTest(@Autowired RouterFunction<?> findVideoByNameRoute) throws IOException {
+	void findVideoByNameRouteTest(@Autowired final RouterFunction<?> findVideoByNameRoute) throws IOException {
 		getWebTestClient(findVideoByNameRoute)
 				.get()
 				.uri("/video/mockVideo")
@@ -67,7 +69,7 @@ void findVideoByNameRouteTest(@Autowired RouterFunction<?> findVideoByNameRoute)
 	}
 
 	@Test
-	void findVideoByNameRouteThrowsTest(@Autowired RouterFunction<?> findVideoByNameRoute) throws IOException {
+	void findVideoByNameRouteThrowsTest(@Autowired final RouterFunction<?> findVideoByNameRoute) throws IOException {
 		getWebTestClient(findVideoByNameRoute)
 				.get()
 				.uri("/video/unknown")
diff --git a/src/test/java/com/kikawet/reactiveMediaServer/service/UserServiceTests.java b/src/test/java/com/kikawet/reactiveMediaServer/service/UserServiceTests.java
index b31f0a0..e971b95 100644
--- a/src/test/java/com/kikawet/reactiveMediaServer/service/UserServiceTests.java
+++ b/src/test/java/com/kikawet/reactiveMediaServer/service/UserServiceTests.java
@@ -1,7 +1,6 @@
 package com.kikawet.reactiveMediaServer.service;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.Mockito.when;
 
 import org.junit.jupiter.api.BeforeEach;
@@ -14,6 +13,8 @@
 import com.kikawet.reactiveMediaServer.model.User;
 import com.kikawet.reactiveMediaServer.repository.UserRepository;
 
+import reactor.test.StepVerifier;
+
 @SpringBootTest
 public class UserServiceTests {
 
@@ -28,12 +29,17 @@ void setUp() {
 		User u = new User();
 		u.setLogin("test");
 
-		when(users.findById("test")).thenReturn(u);
+		when(users.findByLogin(u.getLogin())).thenReturn(u);
 	}
 
 	@Test
 	void getHistoryByLoginThrowsTest() {
-		assertThat(uService.getHistoryByLogin("test")).doesNotContainNull();
-		assertThrows(UnauthorizedUserException.class, () -> uService.getHistoryByLogin("null"));
+		StepVerifier.create(uService.getHistoryByLogin("test"))
+				.assertNext(history -> assertThat(history).isNotNull())
+				.expectComplete();
+
+		StepVerifier.create(uService.getHistoryByLogin("null"))
+				.expectError(UnauthorizedUserException.class)
+				.verify();
 	}
 }
diff --git a/src/test/java/com/kikawet/reactiveMediaServer/service/VideoServiceTests.java b/src/test/java/com/kikawet/reactiveMediaServer/service/VideoServiceTests.java
index 9cc0faf..2994242 100644
--- a/src/test/java/com/kikawet/reactiveMediaServer/service/VideoServiceTests.java
+++ b/src/test/java/com/kikawet/reactiveMediaServer/service/VideoServiceTests.java
@@ -25,6 +25,8 @@
 import com.kikawet.reactiveMediaServer.beans.VideoResourceLoader;
 import com.kikawet.reactiveMediaServer.exception.ResourceNotFoundException;
 
+import reactor.test.StepVerifier;
+
 @SpringBootTest
 public class VideoServiceTests {
 
@@ -57,17 +59,19 @@ void setUp() {
 
 	@Test
 	void findAllVideosTest() {
-		assertThat(vService.findAllVideoTitle()).isNotEmpty()
-				.allSatisfy(videoName -> assertThat(videoExtensions.stream()
-						.filter(extension -> videoName.contains((extension)))
-						.collect(Collectors.toUnmodifiableList())).isEmpty());
+		StepVerifier.create(vService.findAllVideoTitle())
+				.thenConsumeWhile(videoName -> videoExtensions.stream()
+						.filter(ext -> videoName.contains(ext))
+						.collect(Collectors.toUnmodifiableList())
+						.isEmpty())
+				.expectComplete();
 	}
 
 	@Test
 	void findAllVideosPaginationTest() {
-		assertThat(vService.findAllVideoTitle())
-				.isNotEmpty()
-				.hasSize(PageableMapper.DEFAULT_PAGE_REQUEST.getPageSize());
+		StepVerifier.create(vService.findAllVideoTitle())
+				.expectNextCount(PageableMapper.DEFAULT_PAGE_REQUEST.getPageSize())
+				.expectComplete();
 	}
 
 	@Test
diff --git a/src/test/resources/config/application-test.yml b/src/test/resources/config/application-test.yml
new file mode 100644
index 0000000..4aea781
--- /dev/null
+++ b/src/test/resources/config/application-test.yml
@@ -0,0 +1,15 @@
+spring.task.scheduling.pool.size: 1
+
+spring:
+  datasource:
+    url: jdbc:h2:mem:example-app;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE
+    username: sa
+    password:
+    driverClassName: org.h2.Driver
+  sql:
+    init:
+      platform: h2
+  jpa:
+    database-platform: org.hibernate.dialect.H2Dialect
+    hibernate.ddl-auto: create-drop
+    
\ No newline at end of file
diff --git a/src/test/resources/config/application.yml b/src/test/resources/config/application.yml
new file mode 100644
index 0000000..d497ffe
--- /dev/null
+++ b/src/test/resources/config/application.yml
@@ -0,0 +1,2 @@
+spring.profiles.active: "test"
+# spring.config.import: file:src/main/resources/application.yml