diff --git a/dashcaddy-api/routes/backups.js b/dashcaddy-api/routes/backups.js
index e766b1d..fc640d7 100644
--- a/dashcaddy-api/routes/backups.js
+++ b/dashcaddy-api/routes/backups.js
@@ -1,36 +1,32 @@
 const express = require('express');
+const asyncHandler = require('../src/utils/async-handler');
 
-module.exports = function(ctx) {
+module.exports = function({ backupManager }) {
   const router = express.Router();
 
-  // Get backup configuration
-  router.get('/backups/config', ctx.asyncHandler(async (req, res) => {
-    const config = ctx.backupManager.getConfig();
+  router.get('/backups/config', asyncHandler(async (req, res) => {
+    const config = backupManager.getConfig();
     res.json({ success: true, config });
   }, 'backups-config-get'));
 
-  // Update backup configuration
-  router.post('/backups/config', ctx.asyncHandler(async (req, res) => {
-    ctx.backupManager.updateConfig(req.body);
+  router.post('/backups/config', asyncHandler(async (req, res) => {
+    backupManager.updateConfig(req.body);
     res.json({ success: true, message: 'Backup configuration updated' });
   }, 'backups-config-update'));
 
-  // Execute manual backup
-  router.post('/backups/execute', ctx.asyncHandler(async (req, res) => {
-    const backup = await ctx.backupManager.executeBackup('manual', req.body);
+  router.post('/backups/execute', asyncHandler(async (req, res) => {
+    const backup = await backupManager.executeBackup('manual', req.body);
     res.json({ success: true, backup });
   }, 'backups-execute'));
 
-  // Get backup history
-  router.get('/backups/history', ctx.asyncHandler(async (req, res) => {
+  router.get('/backups/history', asyncHandler(async (req, res) => {
     const limit = parseInt(req.query.limit) || 50;
-    const history = ctx.backupManager.getHistory(limit);
+    const history = backupManager.getHistory(limit);
     res.json({ success: true, history });
   }, 'backups-history'));
 
-  // Restore from backup
-  router.post('/backups/restore/:backupId', ctx.asyncHandler(async (req, res) => {
-    const result = await ctx.backupManager.restoreBackup(req.params.backupId, req.body);
+  router.post('/backups/restore/:backupId', asyncHandler(async (req, res) => {
+    const result = await backupManager.restoreBackup(req.params.backupId, req.body);
     res.json({ success: true, result });
   }, 'backups-restore'));
 
diff --git a/dashcaddy-api/routes/credentials.js b/dashcaddy-api/routes/credentials.js
index 11d95d4..56011ff 100644
--- a/dashcaddy-api/routes/credentials.js
+++ b/dashcaddy-api/routes/credentials.js
@@ -1,21 +1,21 @@
 const express = require('express');
+const asyncHandler = require('../src/utils/async-handler');
+const { errorResponse } = require('../src/utils/responses');
 
-module.exports = function(ctx) {
+module.exports = function({ credentialManager }) {
   const router = express.Router();
 
-  // List all stored credentials (keys only, no values)
-  router.get('/credentials/list', ctx.asyncHandler(async (req, res) => {
-    const keys = await ctx.credentialManager.list();
+  router.get('/credentials/list', asyncHandler(async (req, res) => {
+    const keys = await credentialManager.list();
     res.json({ success: true, credentials: keys, count: keys.length });
   }, 'credentials-list'));
 
-  // Rotate encryption key — re-encrypts all stored credentials
-  router.post('/credentials/rotate-key', ctx.asyncHandler(async (req, res) => {
-    const success = await ctx.credentialManager.rotateEncryptionKey();
+  router.post('/credentials/rotate-key', asyncHandler(async (req, res) => {
+    const success = await credentialManager.rotateEncryptionKey();
     if (success) {
       res.json({ success: true, message: 'Encryption key rotated, all credentials re-encrypted' });
     } else {
-      ctx.errorResponse(res, 500, 'Key rotation failed');
+      errorResponse(res, 500, 'Key rotation failed');
     }
   }, 'credentials-rotate'));
 
diff --git a/dashcaddy-api/routes/license.js b/dashcaddy-api/routes/license.js
index 5039c86..41cce63 100644
--- a/dashcaddy-api/routes/license.js
+++ b/dashcaddy-api/routes/license.js
@@ -1,50 +1,44 @@
 const express = require('express');
+const asyncHandler = require('../src/utils/async-handler');
+const { errorResponse } = require('../src/utils/responses');
 
-module.exports = function(ctx) {
+module.exports = function({ licenseManager }) {
   const router = express.Router();
 
-  // Activate a license code
-  router.post('/activate', ctx.asyncHandler(async (req, res) => {
+  router.post('/activate', asyncHandler(async (req, res) => {
     const { code } = req.body;
     if (!code) {
-      return ctx.errorResponse(res, 400, 'License code is required');
+      return errorResponse(res, 400, 'License code is required');
     }
 
-    const result = await ctx.licenseManager.activate(code);
+    const result = await licenseManager.activate(code);
 
     if (result.success) {
-      res.json({
-        success: true,
-        message: result.message,
-        license: result.activation,
-      });
+      res.json({ success: true, message: result.message, license: result.activation });
     } else {
-      ctx.errorResponse(res, 400, result.message);
+      errorResponse(res, 400, result.message);
     }
   }, 'license-activate'));
 
-  // Get current license status
-  router.get('/status', ctx.asyncHandler(async (req, res) => {
-    const status = ctx.licenseManager.getStatus();
+  router.get('/status', asyncHandler(async (req, res) => {
+    const status = licenseManager.getStatus();
     res.json({ success: true, license: status });
   }, 'license-status'));
 
-  // Deactivate current license
-  router.post('/deactivate', ctx.asyncHandler(async (req, res) => {
-    const result = await ctx.licenseManager.deactivate();
+  router.post('/deactivate', asyncHandler(async (req, res) => {
+    const result = await licenseManager.deactivate();
 
     if (result.success) {
       res.json({ success: true, message: result.message });
     } else {
-      ctx.errorResponse(res, 400, result.message);
+      errorResponse(res, 400, result.message);
     }
   }, 'license-deactivate'));
 
-  // Check if a specific feature is available (lightweight check for frontend)
-  router.get('/feature/:feature', ctx.asyncHandler(async (req, res) => {
+  router.get('/feature/:feature', asyncHandler(async (req, res) => {
     const { feature } = req.params;
-    const available = ctx.licenseManager.hasFeature(feature);
-    const status = ctx.licenseManager.getStatus();
+    const available = licenseManager.hasFeature(feature);
+    const status = licenseManager.getStatus();
 
     res.json({
       success: true,