diff --git a/.env.example b/.env.example
index 5975fc6..65a7c16 100644
--- a/.env.example
+++ b/.env.example
@@ -1,4 +1,4 @@
 PORT=3000                       # port to listen to
 BIND=127.0.0.1                  # interface to bind the port
 BASE_URL=http://localhost:3000  # reverse proxy (url users see)
-DATA_DIR=./data                 # where to store database
+DB_PATH=./gists.db              # database file, if inside a folder it needs to exists, if empty runs in memory
diff --git a/src/constants.js b/src/constants.js
index 8eaf5fb..288d8d2 100644
--- a/src/constants.js
+++ b/src/constants.js
@@ -1,6 +1,7 @@
 export const PORT = process.env.PORT;
 export const BIND = process.env.BIND;
 export const BASE_URL = process.env.BASE_URL;
+export const DB_PATH = process.env.DB_PATH;
 
 export const IS_PROD = process.env.NODE_ENV?.startsWith("prod");
 
diff --git a/src/create.js b/src/create.js
index 67ab764..7f73870 100644
--- a/src/create.js
+++ b/src/create.js
@@ -11,18 +11,18 @@ export const encrypt = async (decrypted) => {
     KEY_USAGE
   );
   const { k } = await crypto.subtle.exportKey("jwk", key);
-  const ciphertext = await crypto.subtle.encrypt(
+  const cipherText = await crypto.subtle.encrypt(
     { name: ALGORITHM, iv },
     key,
     decrypted
   );
 
-  return { iv, k, ciphertext };
+  return { iv, k, cipherText };
 };
 
 export const create = async (buffer) => {
-  const { iv, k, ciphertext } = await encrypt(buffer);
-  const uuid = createGist(iv, ciphertext);
+  const { iv, k, cipherText } = await encrypt(buffer);
+  const uuid = createGist(iv, cipherText);
 
   return { uuid, k };
 };
diff --git a/src/database.js b/src/database.js
index 4ede924..422030c 100644
--- a/src/database.js
+++ b/src/database.js
@@ -1,29 +1,30 @@
 import { DatabaseSync } from "node:sqlite";
 import { nanoid } from "nanoid";
+import { DB_PATH } from "./constants.js";
 
-const db = new DatabaseSync(":memory:");
+const db = new DatabaseSync(DB_PATH ? DB_PATH : ":memory:");
 
 db.exec(`
   CREATE TABLE IF NOT EXISTS gists (
     uuid TEXT PRIMARY KEY,
     iv TEXT NOT NULL,
-    data BLOB NOT NULL,
+    cipherText BLOB NOT NULL,
     createAt DATETIME DEFAULT CURRENT_TIMESTAMP
   );
 `);
 
-export const createGist = (iv, data) => {
+export const createGist = (iv, cipherText) => {
   const uuid = nanoid(22);
 
   const query = db.prepare(
-    "INSERT INTO gists (uuid, iv, data) VALUES (?, ?, ?)"
+    "INSERT INTO gists (uuid, iv, cipherText) VALUES (?, ?, ?)"
   );
-  query.run(uuid, iv.toString(), Buffer.from(data));
+  query.run(uuid, iv.toString(), Buffer.from(cipherText));
 
   return uuid;
 };
 
-export const getGists = () => {
-  const query = db.prepare("SELECT * FROM gists");
-  return query.all();
+export const getGist = (uuid) => {
+  const query = db.prepare("SELECT cipherText, iv FROM gists WHERE uuid = ?");
+  return query.get(uuid);
 };
diff --git a/src/routes.js b/src/routes.js
index e37a7a8..9cf97df 100644
--- a/src/routes.js
+++ b/src/routes.js
@@ -1,27 +1,37 @@
 import Router from "@koa/router";
 import { create } from "./create.js";
-import { getGists } from "./database.js";
+import { getGist } from "./database.js";
+import { BASE_URL } from "./constants.js";
 
 export const router = new Router();
 
-router.post("/", async (ctx, next) => {
+router.post("/", async (ctx) => {
   if (!ctx.request.rawBody) {
     return ctx.throw(406, "empty file");
   }
 
   const buffer = Buffer.from(ctx.request.rawBody, "binary");
-  const url = await create(buffer);
+  const { uuid, k } = await create(buffer);
 
   ctx.status = 201;
-  ctx.body = `${url}\n`;
+  ctx.body = `${BASE_URL}/${uuid}#${k}`;
 });
 
-router.get("/", async (ctx, next) => {
-  const gists = getGists();
-  console.log(gists);
+router.get("/", async (ctx) => {
   await ctx.render("home");
 });
 
-router.get("/:id", (ctx, next) => {
-  ctx.body = ctx.params.id;
+router.get("/:uuid{.:ext}", async (ctx, next) => {
+  const gist = getGist(ctx.params.uuid);
+
+  if (!gist) {
+    return next();
+  }
+
+  if (ctx.params.ext !== "bin") {
+    return await ctx.render("view", gist);
+  }
+
+  ctx.set("X-IV", gist.iv);
+  ctx.body = Buffer.from(gist.cipherText);
 });
diff --git a/src/views/view.html b/src/views/view.html
index 850e980..c6c7f87 100644
--- a/src/views/view.html
+++ b/src/views/view.html
@@ -1,5 +1,2 @@
 <pre><code class="loading">still working ⏳</code></pre>
-<script type="module">
-import { init } from "/view.mjs";
-init("<%= contentType %>", new Uint8Array([<%- iv %>]));
-</script>
+<script type="module" src="/view.mjs"></script>
diff --git a/static/subtle.mjs b/static/subtle.mjs
index 1604b90..68aa5a1 100644
--- a/static/subtle.mjs
+++ b/static/subtle.mjs
@@ -18,10 +18,10 @@ export const JWT_PARAMS = {
 /**
  * @param  {Uint8Array}  iv
  * @param  {string}      k
- * @param  {ArrayBuffer} ciphertext
+ * @param  {ArrayBuffer} cipherText
  * @return {Promise<ArrayBuffer>}
  */
-export const decrypt = async (iv, k, ciphertext) => {
+export const decrypt = async (iv, k, cipherText) => {
   const key = await crypto.subtle.importKey(
     "jwk",
     { k, ...JWT_PARAMS },
@@ -30,5 +30,5 @@ export const decrypt = async (iv, k, ciphertext) => {
     KEY_USAGE
   );
 
-  return await crypto.subtle.decrypt({ name: ALGORITHM, iv }, key, ciphertext);
+  return await crypto.subtle.decrypt({ name: ALGORITHM, iv }, key, cipherText);
 };
diff --git a/static/view.mjs b/static/view.mjs
index ae1d06d..7fd8a74 100644
--- a/static/view.mjs
+++ b/static/view.mjs
@@ -70,33 +70,18 @@ const selectLines = (preElement) => {
   setTimeout(() => markElement.scrollIntoView(), 200);
 };
 
-export const init = async (contentType, iv) => {
+addEventListener("DOMContentLoaded", async () => {
   const { uuid, k, forcedLanguage } = parseUrl();
   const preElement = document.createElement("pre");
   let childElement = document.createElement("code");
 
   try {
-    const response = await fetch(`/data/${uuid}`);
-    const encrypted = await response.arrayBuffer();
-    const buffer = await decrypt(iv, k, encrypted);
-
-    if (contentType.startsWith("image/")) {
-      childElement = Object.assign(document.createElement("img"), {
-        src: URL.createObjectURL(new Blob([buffer])),
-      });
-    } else if (contentType.startsWith("video/")) {
-      childElement = Object.assign(document.createElement("video"), {
-        src: URL.createObjectURL(new Blob([buffer])),
-        controls: true,
-      });
-    } else if (contentType.startsWith("audio/")) {
-      childElement = Object.assign(document.createElement("audio"), {
-        src: URL.createObjectURL(new Blob([buffer])),
-        controls: true,
-      });
-    } else {
-      childElement.textContent = new TextDecoder().decode(buffer) || "empty 👀";
-    }
+    const response = await fetch(`/${uuid}.bin`);
+    const iv = new Uint8Array(response.headers.get("X-IV")?.split(","));
+    const cipherText = await response.arrayBuffer();
+    const buffer = await decrypt(iv, k, cipherText);
+
+    childElement.textContent = new TextDecoder().decode(buffer) || "empty 👀";
   } catch (err) {
     console.error(err);
     childElement.textContent = "failed 💀";
@@ -107,10 +92,6 @@ export const init = async (contentType, iv) => {
     document.body.appendChild(preElement);
   }
 
-  if (childElement.tagName.toLowerCase() !== "code") {
-    return;
-  }
-
   if (forcedLanguage) {
     hljs.configure({ languages: [forcedLanguage] });
   }
@@ -123,4 +104,4 @@ export const init = async (contentType, iv) => {
   addLineNumbers(preElement);
   selectLines(preElement);
   addEventListener("hashchange", () => selectLines(preElement));
-};
+});