diff --git a/award-definitions/qo100grids.json b/award-definitions/qo100grids.json
new file mode 100644
index 0000000..1ce8e0f
--- /dev/null
+++ b/award-definitions/qo100grids.json
@@ -0,0 +1,25 @@
+{
+  "id": "qo100grids",
+  "name": "QO100 Grids",
+  "description": "Work as much Grids as possible on QO100 Satellite",
+  "caption": "Work as much Grids as possible on QO100 Satellite",
+  "category": "satellite",
+  "rules": {
+    "type": "entity",
+    "satellite_only": true,
+    "filters": {
+      "operator": "AND",
+      "filters": [
+        {
+          "field": "satName",
+          "operator": "eq",
+          "value": "QO-100"
+        }
+      ]
+    },
+    "entityType": "grid",
+    "target": 100,
+    "displayField": "grid"
+  },
+  "modeGroups": {}
+}
\ No newline at end of file
diff --git a/src/backend/index.js b/src/backend/index.js
index 88c25a1..21406fa 100644
--- a/src/backend/index.js
+++ b/src/backend/index.js
@@ -44,6 +44,14 @@ import {
   getAwardProgressDetails,
   getAwardEntityBreakdown,
 } from './services/awards.service.js';
+import {
+  getAllAwardDefinitions,
+  getAwardDefinition,
+  createAwardDefinition,
+  updateAwardDefinition,
+  deleteAwardDefinition,
+  testAwardCalculation,
+} from './services/awards-admin.service.js';
 import {
   getAutoSyncSettings,
   updateAutoSyncSettings,
@@ -1445,6 +1453,220 @@ const app = new Elysia()
     }
   })
 
+  /**
+   * ================================================================
+   * AWARD MANAGEMENT ROUTES (Admin Only)
+   * ================================================================
+   */
+
+  /**
+   * GET /api/admin/awards
+   * Get all award definitions (admin only)
+   */
+  .get('/api/admin/awards', async ({ user, set }) => {
+    if (!user || !user.isAdmin) {
+      set.status = !user ? 401 : 403;
+      return { success: false, error: !user ? 'Unauthorized' : 'Admin access required' };
+    }
+
+    try {
+      const awards = await getAllAwardDefinitions();
+      return {
+        success: true,
+        awards,
+      };
+    } catch (error) {
+      logger.error('Error fetching award definitions', { error: error.message, userId: user.id });
+      set.status = 500;
+      return {
+        success: false,
+        error: 'Failed to fetch award definitions',
+      };
+    }
+  })
+
+  /**
+   * GET /api/admin/awards/:id
+   * Get a single award definition (admin only)
+   */
+  .get('/api/admin/awards/:id', async ({ user, params, set }) => {
+    if (!user || !user.isAdmin) {
+      set.status = !user ? 401 : 403;
+      return { success: false, error: !user ? 'Unauthorized' : 'Admin access required' };
+    }
+
+    try {
+      const award = await getAwardDefinition(params.id);
+
+      if (!award) {
+        set.status = 404;
+        return {
+          success: false,
+          error: 'Award not found',
+        };
+      }
+
+      return {
+        success: true,
+        award,
+      };
+    } catch (error) {
+      logger.error('Error fetching award definition', { error: error.message, userId: user.id });
+      set.status = 500;
+      return {
+        success: false,
+        error: 'Failed to fetch award definition',
+      };
+    }
+  })
+
+  /**
+   * POST /api/admin/awards
+   * Create a new award definition (admin only)
+   */
+  .post(
+    '/api/admin/awards',
+    async ({ user, body, set }) => {
+      if (!user || !user.isAdmin) {
+        set.status = !user ? 401 : 403;
+        return { success: false, error: !user ? 'Unauthorized' : 'Admin access required' };
+      }
+
+      try {
+        const award = await createAwardDefinition(body);
+        return {
+          success: true,
+          award,
+          message: 'Award definition created successfully',
+        };
+      } catch (error) {
+        logger.error('Error creating award definition', { error: error.message, userId: user.id });
+        set.status = 400;
+        return {
+          success: false,
+          error: error.message,
+        };
+      }
+    },
+    {
+      body: t.Object({
+        id: t.String(),
+        name: t.String(),
+        description: t.String(),
+        caption: t.String(),
+        category: t.String(),
+        rules: t.Any(),
+        modeGroups: t.Optional(t.Any()),
+      }),
+    }
+  )
+
+  /**
+   * PUT /api/admin/awards/:id
+   * Update an award definition (admin only)
+   */
+  .put(
+    '/api/admin/awards/:id',
+    async ({ user, params, body, set }) => {
+      if (!user || !user.isAdmin) {
+        set.status = !user ? 401 : 403;
+        return { success: false, error: !user ? 'Unauthorized' : 'Admin access required' };
+      }
+
+      try {
+        const award = await updateAwardDefinition(params.id, body);
+        return {
+          success: true,
+          award,
+          message: 'Award definition updated successfully',
+        };
+      } catch (error) {
+        logger.error('Error updating award definition', { error: error.message, userId: user.id, awardId: params.id });
+        set.status = 400;
+        return {
+          success: false,
+          error: error.message,
+        };
+      }
+    },
+    {
+      body: t.Object({
+        id: t.Optional(t.String()),
+        name: t.String(),
+        description: t.String(),
+        caption: t.String(),
+        category: t.String(),
+        rules: t.Any(),
+        modeGroups: t.Optional(t.Any()),
+      }),
+    }
+  )
+
+  /**
+   * DELETE /api/admin/awards/:id
+   * Delete an award definition (admin only)
+   */
+  .delete('/api/admin/awards/:id', async ({ user, params, set }) => {
+    if (!user || !user.isAdmin) {
+      set.status = !user ? 401 : 403;
+      return { success: false, error: !user ? 'Unauthorized' : 'Admin access required' };
+    }
+
+    try {
+      const result = await deleteAwardDefinition(params.id);
+      return {
+        success: true,
+        ...result,
+        message: 'Award definition deleted successfully',
+      };
+    } catch (error) {
+      logger.error('Error deleting award definition', { error: error.message, userId: user.id, awardId: params.id });
+      set.status = 400;
+      return {
+        success: false,
+        error: error.message,
+      };
+    }
+  })
+
+  /**
+   * POST /api/admin/awards/:id/test
+   * Test award calculation (admin only)
+   */
+  .post(
+    '/api/admin/awards/:id/test',
+    async ({ user, params, body, set }) => {
+      if (!user || !user.isAdmin) {
+        set.status = !user ? 401 : 403;
+        return { success: false, error: !user ? 'Unauthorized' : 'Admin access required' };
+      }
+
+      try {
+        // Use provided userId or admin's own account
+        const testUserId = body.userId || user.id;
+        const awardDefinition = body.awardDefinition || null;
+        const result = await testAwardCalculation(params.id, testUserId, awardDefinition);
+        return {
+          success: true,
+          ...result,
+        };
+      } catch (error) {
+        logger.error('Error testing award calculation', { error: error.message, userId: user.id, awardId: params.id });
+        set.status = 400;
+        return {
+          success: false,
+          error: error.message,
+        };
+      }
+    },
+    {
+      body: t.Object({
+        userId: t.Optional(t.Integer()),
+        awardDefinition: t.Optional(t.Any()),
+      }),
+    }
+  )
+
   /**
    * ================================================================
    * AUTO-SYNC SETTINGS ROUTES
diff --git a/src/backend/services/awards-admin.service.js b/src/backend/services/awards-admin.service.js
new file mode 100644
index 0000000..b0dca75
--- /dev/null
+++ b/src/backend/services/awards-admin.service.js
@@ -0,0 +1,547 @@
+import { readFileSync, writeFileSync, readdirSync, unlinkSync, existsSync } from 'fs';
+import { join } from 'path';
+import { logger } from '../config.js';
+import { calculateAwardProgress, getAwardById, clearAwardCache } from './awards.service.js';
+
+/**
+ * Awards Admin Service
+ * Manages award definition JSON files for admin operations
+ */
+
+const AWARD_DEFINITIONS_DIR = join(process.cwd(), 'award-definitions');
+
+// Valid entity types for entity rule type
+const VALID_ENTITY_TYPES = ['dxcc', 'state', 'grid', 'callsign'];
+
+// Valid rule types
+const VALID_RULE_TYPES = ['entity', 'dok', 'points', 'filtered', 'counter'];
+
+// Valid count modes for points rule type
+const VALID_COUNT_MODES = ['perStation', 'perBandMode', 'perQso'];
+
+// Valid filter operators
+const VALID_FILTER_OPERATORS = ['eq', 'ne', 'in', 'nin', 'contains'];
+
+// Valid filter fields
+const VALID_FILTER_FIELDS = [
+  'band', 'mode', 'callsign', 'entity', 'entityId', 'state', 'grid', 'satName', 'satellite'
+];
+
+// Valid bands
+const VALID_BANDS = [
+  '160m', '80m', '60m', '40m', '30m', '20m', '17m', '15m', '12m', '10m',
+  '6m', '2m', '70cm', '23cm', '13cm', '9cm', '6cm', '3cm'
+];
+
+// Valid modes
+const VALID_MODES = [
+  'CW', 'SSB', 'AM', 'FM', 'RTTY', 'PSK31', 'FT8', 'FT4', 'JT65', 'JT9',
+  'MFSK', 'Q65', 'JS8', 'FSK441', 'ISCAT', 'JT6M', 'MSK144'
+];
+
+/**
+ * Load all award definitions with file metadata
+ */
+export async function getAllAwardDefinitions() {
+  const definitions = [];
+
+  try {
+    const files = readdirSync(AWARD_DEFINITIONS_DIR)
+      .filter(f => f.endsWith('.json'))
+      .sort();
+
+    for (const file of files) {
+      try {
+        const filePath = join(AWARD_DEFINITIONS_DIR, file);
+        const content = readFileSync(filePath, 'utf-8');
+        const definition = JSON.parse(content);
+
+        // Add file metadata
+        definitions.push({
+          ...definition,
+          _filename: file,
+          _filepath: filePath,
+        });
+      } catch (error) {
+        logger.warn('Failed to load award definition', { file, error: error.message });
+      }
+    }
+  } catch (error) {
+    logger.error('Error reading award definitions directory', { error: error.message });
+  }
+
+  return definitions;
+}
+
+/**
+ * Get a single award definition by ID
+ */
+export async function getAwardDefinition(id) {
+  const definitions = await getAllAwardDefinitions();
+  return definitions.find(def => def.id === id) || null;
+}
+
+/**
+ * Validate an award definition
+ * @returns {Object} { valid: boolean, errors: string[], warnings: string[] }
+ */
+export function validateAwardDefinition(definition, existingDefinitions = []) {
+  const errors = [];
+  const warnings = [];
+
+  // Check required top-level fields
+  const requiredFields = ['id', 'name', 'description', 'caption', 'category', 'rules'];
+  for (const field of requiredFields) {
+    if (!definition[field]) {
+      errors.push(`Missing required field: ${field}`);
+    }
+  }
+
+  // Validate ID
+  if (definition.id) {
+    if (typeof definition.id !== 'string') {
+      errors.push('ID must be a string');
+    } else if (!/^[a-z0-9-]+$/.test(definition.id)) {
+      errors.push('ID must contain only lowercase letters, numbers, and hyphens');
+    } else {
+      // Check for duplicate ID (unless updating existing award)
+      const existingIds = existingDefinitions.map(d => d.id);
+      const isUpdate = existingDefinitions.find(d => d.id === definition.id);
+      const duplicates = existingDefinitions.filter(d => d.id === definition.id);
+      if (duplicates.length > 1 || (duplicates.length === 1 && !isUpdate)) {
+        errors.push(`Award ID "${definition.id}" already exists`);
+      }
+    }
+  }
+
+  // Validate name
+  if (definition.name && typeof definition.name !== 'string') {
+    errors.push('Name must be a string');
+  }
+
+  // Validate description
+  if (definition.description && typeof definition.description !== 'string') {
+    errors.push('Description must be a string');
+  }
+
+  // Validate caption
+  if (definition.caption && typeof definition.caption !== 'string') {
+    errors.push('Caption must be a string');
+  }
+
+  // Validate category
+  if (definition.category && typeof definition.category !== 'string') {
+    errors.push('Category must be a string');
+  }
+
+  // Validate modeGroups if present
+  if (definition.modeGroups) {
+    if (typeof definition.modeGroups !== 'object') {
+      errors.push('modeGroups must be an object');
+    } else {
+      for (const [groupName, modes] of Object.entries(definition.modeGroups)) {
+        if (!Array.isArray(modes)) {
+          errors.push(`modeGroups "${groupName}" must be an array of mode strings`);
+        } else {
+          for (const mode of modes) {
+            if (typeof mode !== 'string') {
+              errors.push(`mode "${mode}" in group "${groupName}" must be a string`);
+            } else if (!VALID_MODES.includes(mode)) {
+              warnings.push(`Unknown mode "${mode}" in group "${groupName}"`);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Validate rules
+  if (!definition.rules) {
+    errors.push('Rules object is required');
+  } else if (typeof definition.rules !== 'object') {
+    errors.push('Rules must be an object');
+  } else {
+    const ruleValidation = validateRules(definition.rules);
+    errors.push(...ruleValidation.errors);
+    warnings.push(...ruleValidation.warnings);
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+  };
+}
+
+/**
+ * Validate rules object
+ */
+function validateRules(rules) {
+  const errors = [];
+  const warnings = [];
+
+  // Check rule type
+  if (!rules.type) {
+    errors.push('Rules must have a type');
+  } else if (!VALID_RULE_TYPES.includes(rules.type)) {
+    errors.push(`Invalid rule type: ${rules.type}. Must be one of: ${VALID_RULE_TYPES.join(', ')}`);
+  }
+
+  // Validate based on rule type
+  switch (rules.type) {
+    case 'entity':
+      validateEntityRule(rules, errors, warnings);
+      break;
+    case 'dok':
+      validateDOKRule(rules, errors, warnings);
+      break;
+    case 'points':
+      validatePointsRule(rules, errors, warnings);
+      break;
+    case 'filtered':
+      validateFilteredRule(rules, errors, warnings);
+      break;
+    case 'counter':
+      validateCounterRule(rules, errors, warnings);
+      break;
+  }
+
+  // Validate filters if present
+  if (rules.filters) {
+    const filterValidation = validateFilters(rules.filters);
+    errors.push(...filterValidation.errors);
+    warnings.push(...filterValidation.warnings);
+  }
+
+  return { errors, warnings };
+}
+
+/**
+ * Validate entity rule
+ */
+function validateEntityRule(rules, errors, warnings) {
+  if (!rules.entityType) {
+    errors.push('Entity rule requires entityType');
+  } else if (!VALID_ENTITY_TYPES.includes(rules.entityType)) {
+    errors.push(`Invalid entityType: ${rules.entityType}. Must be one of: ${VALID_ENTITY_TYPES.join(', ')}`);
+  }
+
+  if (!rules.target || typeof rules.target !== 'number' || rules.target <= 0) {
+    errors.push('Entity rule requires a positive target number');
+  }
+
+  if (rules.allowed_bands) {
+    if (!Array.isArray(rules.allowed_bands)) {
+      errors.push('allowed_bands must be an array');
+    } else {
+      for (const band of rules.allowed_bands) {
+        if (!VALID_BANDS.includes(band)) {
+          warnings.push(`Unknown band in allowed_bands: ${band}`);
+        }
+      }
+    }
+  }
+
+  if (rules.satellite_only !== undefined && typeof rules.satellite_only !== 'boolean') {
+    errors.push('satellite_only must be a boolean');
+  }
+
+  if (rules.displayField && typeof rules.displayField !== 'string') {
+    errors.push('displayField must be a string');
+  }
+}
+
+/**
+ * Validate DOK rule
+ */
+function validateDOKRule(rules, errors, warnings) {
+  if (!rules.target || typeof rules.target !== 'number' || rules.target <= 0) {
+    errors.push('DOK rule requires a positive target number');
+  }
+
+  if (rules.confirmationType && rules.confirmationType !== 'dcl') {
+    warnings.push('DOK rule confirmationType should be "dcl"');
+  }
+
+  if (rules.displayField && typeof rules.displayField !== 'string') {
+    errors.push('displayField must be a string');
+  }
+}
+
+/**
+ * Validate points rule
+ */
+function validatePointsRule(rules, errors, warnings) {
+  if (!rules.target || typeof rules.target !== 'number' || rules.target <= 0) {
+    errors.push('Points rule requires a positive target number');
+  }
+
+  if (!rules.stations || !Array.isArray(rules.stations)) {
+    errors.push('Points rule requires a stations array');
+  } else if (rules.stations.length === 0) {
+    errors.push('Points rule stations array cannot be empty');
+  } else {
+    for (let i = 0; i < rules.stations.length; i++) {
+      const station = rules.stations[i];
+      if (!station.callsign || typeof station.callsign !== 'string') {
+        errors.push(`Station ${i + 1} missing callsign`);
+      }
+      if (typeof station.points !== 'number' || station.points <= 0) {
+        errors.push(`Station ${i + 1} must have positive points value`);
+      }
+    }
+  }
+
+  if (rules.countMode && !VALID_COUNT_MODES.includes(rules.countMode)) {
+    errors.push(`Invalid countMode: ${rules.countMode}. Must be one of: ${VALID_COUNT_MODES.join(', ')}`);
+  }
+}
+
+/**
+ * Validate filtered rule
+ */
+function validateFilteredRule(rules, errors, warnings) {
+  if (!rules.baseRule) {
+    errors.push('Filtered rule requires baseRule');
+  } else {
+    // Recursively validate base rule
+    const baseValidation = validateRules(rules.baseRule);
+    errors.push(...baseValidation.errors);
+    warnings.push(...baseValidation.warnings);
+  }
+
+  if (!rules.filters) {
+    warnings.push('Filtered rule has no filters - baseRule will be used as-is');
+  }
+}
+
+/**
+ * Validate counter rule
+ */
+function validateCounterRule(rules, errors, warnings) {
+  if (!rules.target || typeof rules.target !== 'number' || rules.target <= 0) {
+    errors.push('Counter rule requires a positive target number');
+  }
+
+  if (!rules.countBy) {
+    errors.push('Counter rule requires countBy');
+  } else if (!['qso', 'callsign'].includes(rules.countBy)) {
+    errors.push(`Invalid countBy: ${rules.countBy}. Must be one of: qso, callsign`);
+  }
+
+  if (rules.displayField && typeof rules.displayField !== 'string') {
+    errors.push('displayField must be a string');
+  }
+}
+
+/**
+ * Validate filters object
+ */
+function validateFilters(filters, depth = 0) {
+  const errors = [];
+  const warnings = [];
+
+  if (!filters) {
+    return { errors, warnings };
+  }
+
+  // Prevent infinite recursion
+  if (depth > 10) {
+    errors.push('Filters are too deeply nested (maximum 10 levels)');
+    return { errors, warnings };
+  }
+
+  if (filters.operator && !['AND', 'OR'].includes(filters.operator)) {
+    errors.push(`Invalid filter operator: ${filters.operator}. Must be AND or OR`);
+  }
+
+  if (filters.filters) {
+    if (!Array.isArray(filters.filters)) {
+      errors.push('Filters must be an array');
+    } else {
+      for (const filter of filters.filters) {
+        if (filter.filters) {
+          // Nested filter group
+          const nestedValidation = validateFilters(filter, depth + 1);
+          errors.push(...nestedValidation.errors);
+          warnings.push(...nestedValidation.warnings);
+        } else {
+          // Leaf filter
+          if (!filter.field) {
+            errors.push('Filter missing field');
+          } else if (!VALID_FILTER_FIELDS.includes(filter.field)) {
+            warnings.push(`Unknown filter field: ${filter.field}`);
+          }
+
+          if (!filter.operator) {
+            errors.push('Filter missing operator');
+          } else if (!VALID_FILTER_OPERATORS.includes(filter.operator)) {
+            errors.push(`Invalid filter operator: ${filter.operator}`);
+          }
+
+          if (filter.value === undefined) {
+            errors.push('Filter missing value');
+          }
+
+          if (['in', 'nin'].includes(filter.operator) && !Array.isArray(filter.value)) {
+            errors.push(`Filter operator ${filter.operator} requires an array value`);
+          }
+        }
+      }
+    }
+  }
+
+  return { errors, warnings };
+}
+
+/**
+ * Create a new award definition
+ */
+export async function createAwardDefinition(definition) {
+  // Get all existing definitions for duplicate check
+  const existing = await getAllAwardDefinitions();
+
+  // Validate the definition
+  const validation = validateAwardDefinition(definition, existing);
+  if (!validation.valid) {
+    throw new Error(`Validation failed: ${validation.errors.join('; ')}`);
+  }
+
+  // Create filename from ID
+  const filename = `${definition.id}.json`;
+  const filepath = join(AWARD_DEFINITIONS_DIR, filename);
+
+  // Check if file already exists
+  if (existsSync(filepath)) {
+    throw new Error(`Award file "${filename}" already exists`);
+  }
+
+  // Remove metadata fields before saving
+  const { _filename, _filepath, ...cleanDefinition } = definition;
+
+  // Write to file
+  writeFileSync(filepath, JSON.stringify(cleanDefinition, null, 2), 'utf-8');
+
+  // Clear the cache so new award is immediately available
+  clearAwardCache();
+
+  logger.info('Created award definition', { id: definition.id, filename });
+
+  return {
+    ...cleanDefinition,
+    _filename: filename,
+    _filepath: filepath,
+  };
+}
+
+/**
+ * Update an existing award definition
+ */
+export async function updateAwardDefinition(id, updatedDefinition) {
+  // Get existing definition
+  const existing = await getAwardDefinition(id);
+  if (!existing) {
+    throw new Error(`Award "${id}" not found`);
+  }
+
+  // Ensure ID matches
+  if (updatedDefinition.id && updatedDefinition.id !== id) {
+    throw new Error('Cannot change award ID');
+  }
+
+  // Set the ID from the parameter
+  updatedDefinition.id = id;
+
+  // Get all definitions for validation
+  const allDefinitions = await getAllAwardDefinitions();
+
+  // Validate the updated definition
+  const validation = validateAwardDefinition(updatedDefinition, allDefinitions);
+  if (!validation.valid) {
+    throw new Error(`Validation failed: ${validation.errors.join('; ')}`);
+  }
+
+  // Keep the same filename
+  const filename = existing._filename;
+  const filepath = existing._filepath;
+
+  // Remove metadata fields before saving
+  const { _filename, _filepath, ...cleanDefinition } = updatedDefinition;
+
+  // Write to file
+  writeFileSync(filepath, JSON.stringify(cleanDefinition, null, 2), 'utf-8');
+
+  // Clear the cache so updated award is immediately available
+  clearAwardCache();
+
+  logger.info('Updated award definition', { id, filename });
+
+  return {
+    ...cleanDefinition,
+    _filename: filename,
+    _filepath: filepath,
+  };
+}
+
+/**
+ * Delete an award definition
+ */
+export async function deleteAwardDefinition(id) {
+  const existing = await getAwardDefinition(id);
+  if (!existing) {
+    throw new Error(`Award "${id}" not found`);
+  }
+
+  // Delete the file
+  unlinkSync(existing._filepath);
+
+  // Clear the cache so deleted award is immediately removed
+  clearAwardCache();
+
+  logger.info('Deleted award definition', { id, filename: existing._filename });
+
+  return { success: true, id };
+}
+
+/**
+ * Test award calculation for a user
+ * @param {string} id - Award ID (must exist unless awardDefinition is provided)
+ * @param {number} userId - User ID to test with
+ * @param {Object} awardDefinition - Optional award definition (for testing unsaved awards)
+ */
+export async function testAwardCalculation(id, userId, awardDefinition = null) {
+  // Get award definition - either from parameter or from cache
+  let award = awardDefinition;
+  if (!award) {
+    award = getAwardById(id);
+    if (!award) {
+      throw new Error(`Award "${id}" not found`);
+    }
+  }
+
+  // Calculate progress
+  const progress = await calculateAwardProgress(userId, award);
+
+  // Warn if no matches
+  const warnings = [];
+  if (progress.worked === 0 && progress.confirmed === 0) {
+    warnings.push('No QSOs matched the award criteria. Check filters and band/mode restrictions.');
+  }
+
+  // Get sample entities
+  const sampleEntities = (progress.confirmedEntities || []).slice(0, 10);
+
+  return {
+    award: {
+      id: award.id,
+      name: award.name,
+      description: award.description,
+    },
+    worked: progress.worked,
+    confirmed: progress.confirmed,
+    target: progress.target,
+    percentage: progress.percentage,
+    sampleEntities,
+    warnings,
+  };
+}
diff --git a/src/backend/services/awards.service.js b/src/backend/services/awards.service.js
index b7bea4a..fe3925a 100644
--- a/src/backend/services/awards.service.js
+++ b/src/backend/services/awards.service.js
@@ -53,6 +53,15 @@ function loadAwardDefinitions() {
   return definitions;
 }
 
+/**
+ * Clear the cached award definitions
+ * Call this after creating, updating, or deleting award definitions
+ */
+export function clearAwardCache() {
+  cachedAwardDefinitions = null;
+  logger.info('Award cache cleared');
+}
+
 /**
  * Get all available awards
  */
diff --git a/src/frontend/src/lib/api.js b/src/frontend/src/lib/api.js
index 2464fed..4987458 100644
--- a/src/frontend/src/lib/api.js
+++ b/src/frontend/src/lib/api.js
@@ -130,3 +130,29 @@ export const autoSyncAPI = {
 
   getSchedulerStatus: () => apiRequest('/auto-sync/scheduler/status'),
 };
+
+// Awards Admin API
+export const awardsAdminAPI = {
+  getAll: () => apiRequest('/admin/awards'),
+
+  getById: (id) => apiRequest(`/admin/awards/${id}`),
+
+  create: (data) => apiRequest('/admin/awards', {
+    method: 'POST',
+    body: JSON.stringify(data),
+  }),
+
+  update: (id, data) => apiRequest(`/admin/awards/${id}`, {
+    method: 'PUT',
+    body: JSON.stringify(data),
+  }),
+
+  delete: (id) => apiRequest(`/admin/awards/${id}`, {
+    method: 'DELETE',
+  }),
+
+  test: (id, userId, awardDefinition) => apiRequest(`/admin/awards/${id}/test`, {
+    method: 'POST',
+    body: JSON.stringify({ userId, awardDefinition }),
+  }),
+};
diff --git a/src/frontend/src/routes/admin/+page.svelte b/src/frontend/src/routes/admin/+page.svelte
index 06b7fb1..5f6b33d 100644
--- a/src/frontend/src/routes/admin/+page.svelte
+++ b/src/frontend/src/routes/admin/+page.svelte
@@ -12,7 +12,7 @@
   let impersonationStatus = null;
 
   // UI state
-  let selectedTab = 'overview'; // 'overview', 'users', 'actions'
+  let selectedTab = 'overview'; // 'overview', 'users', 'awards', 'actions'
   let showImpersonationModal = false;
   let showDeleteUserModal = false;
   let showRoleChangeModal = false;
@@ -226,6 +226,12 @@
       >
         Users
       </button>
+      <button
+        class="tab {selectedTab === 'awards' ? 'active' : ''}"
+        on:click={() => selectedTab = 'awards'}
+      >
+        Awards
+      </button>
       <button
         class="tab {selectedTab === 'actions' ? 'active' : ''}"
         on:click={() => selectedTab = 'actions'}
@@ -382,6 +388,30 @@
       </div>
     {/if}
 
+    <!-- Awards Tab -->
+    {#if selectedTab === 'awards'}
+      <div class="tab-content">
+        <h2>Award Definitions</h2>
+        <p class="help-text">Manage award definitions. Create, edit, and delete awards.</p>
+
+        <div class="awards-quick-actions">
+          <a href="/admin/awards" class="btn btn-primary">Manage Awards</a>
+        </div>
+
+        <div class="awards-info">
+          <h3>Award Management</h3>
+          <p>From the Awards management page, you can:</p>
+          <ul>
+            <li><strong>Create</strong> new award definitions</li>
+            <li><strong>Edit</strong> existing award definitions</li>
+            <li><strong>Delete</strong> awards</li>
+            <li><strong>Test</strong> award calculations with sample user data</li>
+          </ul>
+          <p>All award definitions are stored as JSON files in the <code>award-definitions/</code> directory.</p>
+        </div>
+      </div>
+    {/if}
+
     <!-- Actions Tab -->
     {#if selectedTab === 'actions'}
       <div class="tab-content">
@@ -919,6 +949,50 @@
     cursor: pointer;
   }
 
+  .help-text {
+    color: #666;
+    font-style: italic;
+    margin-bottom: 1rem;
+  }
+
+  .awards-quick-actions {
+    margin-bottom: 2rem;
+  }
+
+  .awards-info {
+    background-color: #f9f9f9;
+    border-left: 4px solid #667eea;
+    padding: 1.5rem;
+    border-radius: 4px;
+  }
+
+  .awards-info h3 {
+    margin-top: 0;
+    margin-bottom: 1rem;
+    color: #333;
+  }
+
+  .awards-info p {
+    margin-bottom: 1rem;
+  }
+
+  .awards-info ul {
+    margin-bottom: 1rem;
+    padding-left: 1.5rem;
+  }
+
+  .awards-info li {
+    margin-bottom: 0.5rem;
+  }
+
+  .awards-info code {
+    background-color: #e0e0e0;
+    padding: 0.2rem 0.4rem;
+    border-radius: 3px;
+    font-family: monospace;
+    font-size: 0.9rem;
+  }
+
   @media (max-width: 768px) {
     .users-header {
       flex-direction: column;
diff --git a/src/frontend/src/routes/admin/awards/+page.svelte b/src/frontend/src/routes/admin/awards/+page.svelte
new file mode 100644
index 0000000..0a8063d
--- /dev/null
+++ b/src/frontend/src/routes/admin/awards/+page.svelte
@@ -0,0 +1,379 @@
+<script>
+  import { onMount } from 'svelte';
+  import { auth } from '$lib/stores.js';
+  import { awardsAdminAPI } from '$lib/api.js';
+  import { browser } from '$app/environment';
+
+  let loading = true;
+  let error = null;
+  let awards = [];
+  let searchQuery = '';
+  let categoryFilter = 'all';
+
+  onMount(async () => {
+    if (!$auth.user) {
+      window.location.href = '/auth/login';
+      return;
+    }
+
+    if (!$auth.user.isAdmin) {
+      error = 'Admin access required';
+      loading = false;
+      return;
+    }
+
+    await loadAwards();
+    loading = false;
+  });
+
+  async function loadAwards() {
+    try {
+      const data = await awardsAdminAPI.getAll();
+      awards = data.awards || [];
+    } catch (err) {
+      error = err.message;
+    }
+  }
+
+  async function handleDelete(id) {
+    const award = awards.find(a => a.id === id);
+    if (!award) return;
+
+    if (!confirm(`Are you sure you want to delete award "${award.name}"?\n\nThis action cannot be undone.`)) {
+      return;
+    }
+
+    try {
+      loading = true;
+      await awardsAdminAPI.delete(id);
+      await loadAwards();
+    } catch (err) {
+      alert('Failed to delete award: ' + err.message);
+    } finally {
+      loading = false;
+    }
+  }
+
+  function getRuleTypeDisplayName(ruleType) {
+    const names = {
+      'entity': 'Entity',
+      'dok': 'DOK',
+      'points': 'Points',
+      'filtered': 'Filtered',
+      'counter': 'Counter'
+    };
+    return names[ruleType] || ruleType;
+  }
+
+  function getCategoryColor(category) {
+    const colors = {
+      'dxcc': 'purple',
+      'darc': 'orange',
+      'vucc': 'blue',
+      'was': 'green',
+      'special': 'red',
+    };
+    return colors[category] || 'gray';
+  }
+
+  $: filteredAwards = awards.filter(award => {
+    const matchesSearch = !searchQuery ||
+      award.name.toLowerCase().includes(searchQuery.toLowerCase()) ||
+      award.id.toLowerCase().includes(searchQuery.toLowerCase()) ||
+      award.category.toLowerCase().includes(searchQuery.toLowerCase());
+
+    const matchesCategory = categoryFilter === 'all' || award.category === categoryFilter;
+
+    return matchesSearch && matchesCategory;
+  });
+
+  $: categories = [...new Set(awards.map(a => a.category))].sort();
+</script>
+
+{#if loading && awards.length === 0}
+  <div class="loading">Loading award definitions...</div>
+{:else if error}
+  <div class="error">{error}</div>
+{:else}
+  <div class="awards-admin">
+    <div class="header">
+      <h1>Award Definitions</h1>
+      <a href="/admin/awards/create" class="btn btn-primary">Create New Award</a>
+    </div>
+
+    <div class="filters">
+      <input
+        type="text"
+        class="search-input"
+        placeholder="Search by name, ID, or category..."
+        bind:value={searchQuery}
+      />
+      <select class="category-filter" bind:value={categoryFilter}>
+        <option value="all">All Categories</option>
+        {#each categories as category}
+          <option value={category}>{category}</option>
+        {/each}
+      </select>
+    </div>
+
+    <div class="awards-table-container">
+      <table class="awards-table">
+        <thead>
+          <tr>
+            <th>ID</th>
+            <th>Name</th>
+            <th>Category</th>
+            <th>Rule Type</th>
+            <th>Target</th>
+            <th>Actions</th>
+          </tr>
+        </thead>
+        <tbody>
+          {#each filteredAwards as award}
+            <tr>
+              <td class="id-cell">{award.id}</td>
+              <td>
+                <div class="name-cell">
+                  <strong>{award.name}</strong>
+                  <small>{award.description}</small>
+                </div>
+              </td>
+              <td>
+                <span class="category-badge {getCategoryColor(award.category)}">
+                  {award.category}
+                </span>
+              </td>
+              <td>{getRuleTypeDisplayName(award.rules.type)}</td>
+              <td>{award.rules.target || '-'}</td>
+              <td class="actions-cell">
+                <a href="/admin/awards/{award.id}" class="action-btn edit-btn">Edit</a>
+                <a href="/awards/{award.id}" target="_blank" class="action-btn view-btn">View</a>
+                <button
+                  class="action-btn delete-btn"
+                  on:click={() => handleDelete(award.id)}
+                >
+                  Delete
+                </button>
+              </td>
+            </tr>
+          {/each}
+        </tbody>
+      </table>
+    </div>
+
+    <p class="count">Showing {filteredAwards.length} award(s)</p>
+  </div>
+{/if}
+
+<style>
+  .awards-admin {
+    padding: 2rem;
+    max-width: 1400px;
+    margin: 0 auto;
+  }
+
+  .loading {
+    text-align: center;
+    padding: 3rem;
+    font-size: 1.2rem;
+    color: #666;
+  }
+
+  .error {
+    background-color: #fee;
+    border: 1px solid #fcc;
+    padding: 1rem;
+    border-radius: 4px;
+    color: #c00;
+    margin: 2rem;
+  }
+
+  .header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1.5rem;
+    flex-wrap: wrap;
+    gap: 1rem;
+  }
+
+  .header h1 {
+    margin: 0;
+    color: #333;
+  }
+
+  .filters {
+    display: flex;
+    gap: 1rem;
+    margin-bottom: 1.5rem;
+    flex-wrap: wrap;
+  }
+
+  .search-input,
+  .category-filter {
+    padding: 0.5rem 0.75rem;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    font-size: 0.9rem;
+  }
+
+  .search-input {
+    flex: 1;
+    min-width: 250px;
+  }
+
+  .category-filter {
+    min-width: 150px;
+  }
+
+  .btn {
+    padding: 0.6rem 1.2rem;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    font-weight: 500;
+    text-decoration: none;
+    display: inline-block;
+    transition: all 0.2s;
+  }
+
+  .btn-primary {
+    background-color: #667eea;
+    color: white;
+  }
+
+  .btn-primary:hover {
+    background-color: #5568d3;
+  }
+
+  .awards-table-container {
+    overflow-x: auto;
+    background: white;
+    border-radius: 8px;
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+  }
+
+  .awards-table {
+    width: 100%;
+    border-collapse: collapse;
+  }
+
+  .awards-table th,
+  .awards-table td {
+    padding: 0.75rem 1rem;
+    text-align: left;
+    border-bottom: 1px solid #e0e0e0;
+  }
+
+  .awards-table th {
+    background-color: #f5f5f5;
+    font-weight: 600;
+    text-transform: uppercase;
+    font-size: 0.8rem;
+    color: #666;
+  }
+
+  .awards-table tr:hover {
+    background-color: #f9f9f9;
+  }
+
+  .id-cell {
+    font-family: monospace;
+    color: #666;
+    font-size: 0.9rem;
+  }
+
+  .name-cell {
+    display: flex;
+    flex-direction: column;
+  }
+
+  .name-cell small {
+    color: #888;
+    font-size: 0.85rem;
+    margin-top: 0.25rem;
+  }
+
+  .category-badge {
+    padding: 0.25rem 0.75rem;
+    border-radius: 12px;
+    font-size: 0.8rem;
+    font-weight: 600;
+    display: inline-block;
+  }
+
+  .category-badge.purple { background-color: #9b59b6; color: white; }
+  .category-badge.orange { background-color: #e67e22; color: white; }
+  .category-badge.blue { background-color: #3498db; color: white; }
+  .category-badge.green { background-color: #27ae60; color: white; }
+  .category-badge.red { background-color: #e74c3c; color: white; }
+  .category-badge.gray { background-color: #95a5a6; color: white; }
+
+  .actions-cell {
+    white-space: nowrap;
+  }
+
+  .action-btn {
+    padding: 0.4rem 0.8rem;
+    margin-right: 0.3rem;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 0.85rem;
+    text-decoration: none;
+    display: inline-block;
+    transition: all 0.2s;
+  }
+
+  .edit-btn {
+    background-color: #3498db;
+    color: white;
+  }
+
+  .edit-btn:hover {
+    background-color: #2980b9;
+  }
+
+  .view-btn {
+    background-color: #27ae60;
+    color: white;
+  }
+
+  .view-btn:hover {
+    background-color: #219a52;
+  }
+
+  .delete-btn {
+    background-color: #e74c3c;
+    color: white;
+  }
+
+  .delete-btn:hover {
+    background-color: #c0392b;
+  }
+
+  .count {
+    margin-top: 1rem;
+    color: #666;
+    font-style: italic;
+  }
+
+  @media (max-width: 768px) {
+    .awards-admin {
+      padding: 1rem;
+    }
+
+    .header {
+      flex-direction: column;
+      align-items: stretch;
+    }
+
+    .filters {
+      flex-direction: column;
+    }
+
+    .search-input {
+      width: 100%;
+    }
+  }
+</style>
diff --git a/src/frontend/src/routes/admin/awards/[id]/+page.svelte b/src/frontend/src/routes/admin/awards/[id]/+page.svelte
new file mode 100644
index 0000000..ea9b8a5
--- /dev/null
+++ b/src/frontend/src/routes/admin/awards/[id]/+page.svelte
@@ -0,0 +1,1162 @@
+<script>
+  import { onMount } from 'svelte';
+  import { browser } from '$app/environment';
+  import { awardsAdminAPI } from '$lib/api.js';
+  import FilterBuilder from '../components/FilterBuilder.svelte';
+  import TestAwardModal from '../components/TestAwardModal.svelte';
+
+  let loading = true;
+  let saving = false;
+  let error = null;
+  let awardId = null;
+
+  // UI state
+  let showTestModal = false;
+  let activeTab = 'basic'; // basic, modeGroups, rules
+
+  // Form data
+  let formData = {
+    id: '',
+    name: '',
+    description: '',
+    caption: '',
+    category: '',
+    modeGroups: {},
+    rules: {
+      type: 'entity',
+    }
+  };
+
+  // Available bands and modes
+  const ALL_BANDS = ['160m', '80m', '60m', '40m', '30m', '20m', '17m', '15m', '12m', '10m', '6m', '2m', '70cm', '23cm', '13cm', '9cm', '6cm', '3cm'];
+  const ALL_MODES = ['CW', 'SSB', 'AM', 'FM', 'RTTY', 'PSK31', 'FT8', 'FT4', 'JT65', 'JT9', 'MFSK', 'Q65', 'JS8', 'FSK441', 'ISCAT', 'JT6M', 'MSK144'];
+
+  // Validation errors and warnings
+  let validationErrors = [];
+  let validationWarnings = [];
+
+  // Mode groups editor state
+  let newModeGroupName = '';
+  let newModeGroupModes = [];
+
+  // Get award ID from URL
+  onMount(async () => {
+    const pathParts = window.location.pathname.split('/');
+    awardId = pathParts[pathParts.length - 1];
+    await loadAward(awardId);
+  });
+
+  async function loadAward(id) {
+    loading = true;
+    try {
+      const data = await awardsAdminAPI.getById(id);
+      formData = {
+        id: data.award.id || '',
+        name: data.award.name || '',
+        description: data.award.description || '',
+        caption: data.award.caption || '',
+        category: data.award.category || '',
+        modeGroups: data.award.modeGroups || {},
+        rules: data.award.rules || { type: 'entity' },
+      };
+      awardId = id;
+    } catch (err) {
+      error = 'Failed to load award: ' + err.message;
+    } finally {
+      loading = false;
+    }
+  }
+
+  // Safety validation - checks for senseless logic and redundancies
+  function performSafetyValidation() {
+    const errors = [];
+    const warnings = [];
+
+    // Basic field validation
+    if (!formData.id.trim()) errors.push('ID is required');
+    if (!formData.name.trim()) errors.push('Name is required');
+    if (!formData.description.trim()) errors.push('Description is required');
+    if (!formData.caption.trim()) errors.push('Caption is required');
+    if (!formData.category.trim()) errors.push('Category is required');
+
+    // ID format validation
+    if (formData.id && !/^[a-z0-9-]+$/.test(formData.id)) {
+      errors.push('ID must contain only lowercase letters, numbers, and hyphens');
+    }
+
+    // Rules validation
+    if (!formData.rules.type) {
+      errors.push('Rule type is required');
+    }
+
+    // Rule-specific validation
+    switch (formData.rules.type) {
+      case 'entity':
+        validateEntityRule(errors, warnings);
+        break;
+      case 'dok':
+        validateDOKRule(errors, warnings);
+        break;
+      case 'points':
+        validatePointsRule(errors, warnings);
+        break;
+      case 'filtered':
+        validateFilteredRule(errors, warnings);
+        break;
+      case 'counter':
+        validateCounterRule(errors, warnings);
+        break;
+    }
+
+    // Mode groups validation
+    validateModeGroups(errors, warnings);
+
+    // Cross-field validation
+    performCrossFieldValidation(errors, warnings);
+
+    validationErrors = errors;
+    validationWarnings = warnings;
+
+    return errors.length === 0;
+  }
+
+  function validateEntityRule(errors, warnings) {
+    if (!formData.rules.entityType) {
+      errors.push('Entity rule requires entityType');
+    }
+
+    if (!formData.rules.target || formData.rules.target <= 0) {
+      errors.push('Target must be a positive number');
+    }
+
+    // Check for redundant filters
+    if (formData.rules.allowed_bands && formData.rules.filters) {
+      // Check if filters contain a band restriction that conflicts with allowed_bands
+      const filterBands = extractBandFilters(formData.rules.filters);
+      if (filterBands.length > 0) {
+        const overlap = filterBands.every(b => formData.rules.allowed_bands.includes(b));
+        if (overlap) {
+          warnings.push('Band filters are redundant - all filtered bands are already in allowed_bands');
+        }
+      }
+    }
+
+    // Check if satellite_only makes sense with allowed_bands
+    if (formData.rules.satellite_only && formData.rules.allowed_bands) {
+      const satBands = ['2m', '70cm', '23cm', '13cm', '9cm', '6cm', '3cm'];
+      const hasSatBands = formData.rules.allowed_bands.some(b => satBands.includes(b));
+      if (!hasSatBands) {
+        warnings.push('satellite_only is set but no satellite-capable bands (2m, 70cm, etc.) are in allowed_bands');
+      }
+    }
+  }
+
+  function validateDOKRule(errors, warnings) {
+    if (!formData.rules.target || formData.rules.target <= 0) {
+      errors.push('Target must be a positive number');
+    }
+
+    if (formData.rules.confirmationType && formData.rules.confirmationType !== 'dcl') {
+      warnings.push('DOK awards typically use "dcl" as confirmationType');
+    }
+  }
+
+  function validatePointsRule(errors, warnings) {
+    if (!formData.rules.target || formData.rules.target <= 0) {
+      errors.push('Target must be a positive number');
+    }
+
+    if (!formData.rules.stations || formData.rules.stations.length === 0) {
+      errors.push('Points rule requires at least one station');
+    }
+
+    // Check for duplicate callsigns
+    if (formData.rules.stations) {
+      const callsigns = formData.rules.stations.map(s => s.callsign?.toUpperCase());
+      const duplicates = callsigns.filter((c, i) => callsigns.indexOf(c) !== i);
+      if (duplicates.length > 0) {
+        errors.push(`Duplicate station callsigns: ${[...new Set(duplicates)].join(', ')}`);
+      }
+
+      // Check for zero or negative points
+      formData.rules.stations.forEach((station, i) => {
+        if (!station.callsign || !station.callsign.trim()) {
+          errors.push(`Station ${i + 1} is missing callsign`);
+        }
+        if (typeof station.points !== 'number' || station.points <= 0) {
+          errors.push(`Station ${station.callsign || i + 1} must have positive points value`);
+        }
+      });
+    }
+  }
+
+  function validateFilteredRule(errors, warnings) {
+    if (!formData.rules.baseRule) {
+      errors.push('Filtered rule requires baseRule');
+    } else {
+      // Recursively validate base rule
+      const baseRule = formData.rules.baseRule;
+      if (baseRule.type === 'filtered') {
+        errors.push('Nested filtered rules are not supported');
+      }
+    }
+
+    // Check if filters are empty
+    if (!formData.rules.filters || !formData.rules.filters.filters || formData.rules.filters.filters.length === 0) {
+      warnings.push('Filtered rule has no filters - baseRule will be used as-is');
+    }
+  }
+
+  function validateCounterRule(errors, warnings) {
+    if (!formData.rules.target || formData.rules.target <= 0) {
+      errors.push('Target must be a positive number');
+    }
+
+    if (!formData.rules.countBy) {
+      errors.push('Counter rule requires countBy (qso or callsign)');
+    }
+  }
+
+  function validateModeGroups(errors, warnings) {
+    if (!formData.modeGroups) return;
+
+    // Check for empty mode groups
+    for (const [name, modes] of Object.entries(formData.modeGroups)) {
+      if (!Array.isArray(modes) || modes.length === 0) {
+        warnings.push(`Mode group "${name}" is empty`);
+      }
+    }
+
+    // Check for duplicate mode names within a group
+    for (const [name, modes] of Object.entries(formData.modeGroups)) {
+      if (Array.isArray(modes)) {
+        const duplicates = modes.filter((m, i) => modes.indexOf(m) !== i);
+        if (duplicates.length > 0) {
+          warnings.push(`Mode group "${name}" contains duplicates: ${[...new Set(duplicates)].join(', ')}`);
+        }
+      }
+    }
+
+    // Check for redundant mode groups (identical mode sets)
+    const groupKeys = Object.keys(formData.modeGroups);
+    for (let i = 0; i < groupKeys.length; i++) {
+      for (let j = i + 1; j < groupKeys.length; j++) {
+        const modes1 = JSON.stringify(formData.modeGroups[groupKeys[i]]?.sort());
+        const modes2 = JSON.stringify(formData.modeGroups[groupKeys[j]]?.sort());
+        if (modes1 === modes2 && modes1 !== undefined) {
+          warnings.push(`Mode groups "${groupKeys[i]}" and "${groupKeys[j]}" have identical mode sets`);
+        }
+      }
+    }
+
+    // Check if modes are in the known modes list
+    for (const [name, modes] of Object.entries(formData.modeGroups)) {
+      if (Array.isArray(modes)) {
+        const unknownModes = modes.filter(m => !ALL_MODES.includes(m));
+        if (unknownModes.length > 0) {
+          warnings.push(`Mode group "${name}" contains unknown modes: ${unknownModes.join(', ')}`);
+        }
+      }
+    }
+  }
+
+  function performCrossFieldValidation(errors, warnings) {
+    // Check if filters contradict satellite_only
+    if (formData.rules.satellite_only && formData.rules.filters) {
+      const satFilter = findFilterByField(formData.rules.filters, 'satellite');
+      if (satFilter && satFilter.operator === 'eq' && satFilter.value === false) {
+        errors.push('Conflict: satellite_only is true but filter sets satellite=false');
+      }
+    }
+
+    // Check if filters contradict allowed_bands
+    if (formData.rules.allowed_bands && formData.rules.filters) {
+      const bandFilters = extractAllBandFilters(formData.rules.filters);
+      for (const bandFilter of bandFilters) {
+        if (bandFilter.operator === 'nin' && Array.isArray(bandFilter.value)) {
+          // Check if nin filter excludes all allowed_bands
+          const allExcluded = formData.rules.allowed_bands.every(b => bandFilter.value.includes(b));
+          if (allExcluded) {
+            errors.push('Filter excludes all bands in allowed_bands - no QSOs will match');
+          }
+        }
+      }
+    }
+
+    // Check for contradictory filter combinations (e.g., mode=CW AND mode=SSB)
+    if (formData.rules.filters && formData.rules.filters.operator === 'AND') {
+      const fieldFilters = groupFiltersByField(formData.rules.filters);
+      for (const [field, filters] of Object.entries(fieldFilters)) {
+        if (filters.length > 1) {
+          const eqFilters = filters.filter(f => f.operator === 'eq');
+          if (eqFilters.length > 1) {
+            const values = eqFilters.map(f => f.value);
+            if (new Set(values).size > 1) {
+              errors.push(`Impossible filter: ${field} cannot equal multiple values (${values.join(', ')}) with AND operator`);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Helper functions for filter analysis
+  function extractBandFilters(filters, depth = 0) {
+    if (!filters || depth > 5) return [];
+    const result = [];
+
+    if (filters.field === 'band') {
+      result.push(filters);
+    }
+
+    if (filters.filters) {
+      for (const f of filters.filters) {
+        result.push(...extractBandFilters(f, depth + 1));
+      }
+    }
+
+    return result;
+  }
+
+  function extractAllBandFilters(filters) {
+    return extractBandFilters(filters);
+  }
+
+  function findFilterByField(filters, field, depth = 0) {
+    if (!filters || depth > 5) return null;
+
+    if (filters.field === field) return filters;
+
+    if (filters.filters) {
+      for (const f of filters.filters) {
+        const found = findFilterByField(f, field, depth + 1);
+        if (found) return found;
+      }
+    }
+
+    return null;
+  }
+
+  function groupFiltersByField(filters, depth = 0) {
+    if (!filters || depth > 5) return {};
+
+    const result = {};
+
+    if (filters.field) {
+      if (!result[filters.field]) result[filters.field] = [];
+      result[filters.field].push(filters);
+    }
+
+    if (filters.filters) {
+      for (const f of filters.filters) {
+        const nested = groupFiltersByField(f, depth + 1);
+        for (const [field, fList] of Object.entries(nested)) {
+          if (!result[field]) result[field] = [];
+          result[field].push(...fList);
+        }
+      }
+    }
+
+    return result;
+  }
+
+  async function handleSave() {
+    if (!performSafetyValidation()) {
+      return;
+    }
+
+    saving = true;
+    error = null;
+
+    try {
+      await awardsAdminAPI.update(awardId, formData);
+      window.location.href = '/admin/awards';
+    } catch (err) {
+      error = err.message;
+    } finally {
+      saving = false;
+    }
+  }
+
+  function handleRulesChange(newRules) {
+    formData = { ...formData, rules: newRules };
+    performSafetyValidation();
+  }
+
+  function handleFiltersChange(newFilters) {
+    formData = { ...formData, rules: { ...formData.rules, filters: newFilters } };
+    performSafetyValidation();
+  }
+
+  // Mode groups management
+  function addModeGroup() {
+    if (!newModeGroupName.trim()) return;
+    if (!newModeGroupModes.length) {
+      alert('Please add at least one mode to the group');
+      return;
+    }
+
+    if (formData.modeGroups[newModeGroupName]) {
+      alert('A mode group with this name already exists');
+      return;
+    }
+
+    formData = {
+      ...formData,
+      modeGroups: {
+        ...formData.modeGroups,
+        [newModeGroupName]: [...newModeGroupModes],
+      }
+    };
+
+    newModeGroupName = '';
+    newModeGroupModes = [];
+    performSafetyValidation();
+  }
+
+  function removeModeGroup(name) {
+    const { [name]: removed, ...rest } = formData.modeGroups;
+    formData = { ...formData, modeGroups: rest };
+    performSafetyValidation();
+  }
+
+  function testAward() {
+    showTestModal = true;
+  }
+</script>
+
+{#if loading}
+  <div class="loading">Loading award definition...</div>
+{:else}
+  <div class="award-editor">
+    <div class="header">
+      <h1>Edit Award: {formData.name}</h1>
+      <div class="header-actions">
+        <button class="btn btn-secondary" on:click={testAward}>Test Award</button>
+        <button class="btn btn-primary" on:click={handleSave} disabled={saving}>
+          {saving ? 'Saving...' : 'Update Award'}
+        </button>
+      </div>
+    </div>
+
+    {#if error}
+      <div class="error">{error}</div>
+    {/if}
+
+    {#if validationErrors.length > 0}
+      <div class="validation-errors">
+        <h3>Please fix the following errors:</h3>
+        <ul>
+          {#each validationErrors as err}
+            <li>{err}</li>
+          {/each}
+        </ul>
+      </div>
+    {/if}
+
+    {#if validationWarnings.length > 0}
+      <div class="validation-warnings">
+        <h3>Warnings:</h3>
+        <ul>
+          {#each validationWarnings as warn}
+            <li>{warn}</li>
+          {/each}
+        </ul>
+      </div>
+    {/if}
+
+    <div class="tabs">
+      <button
+        class="tab {activeTab === 'basic' ? 'active' : ''}"
+        on:click={() => activeTab = 'basic'}
+      >
+        Basic Info
+      </button>
+      <button
+        class="tab {activeTab === 'modeGroups' ? 'active' : ''}"
+        on:click={() => activeTab = 'modeGroups'}
+      >
+        Mode Groups
+      </button>
+      <button
+        class="tab {activeTab === 'rules' ? 'active' : ''}"
+        on:click={() => activeTab = 'rules'}
+      >
+        Rules
+      </button>
+    </div>
+
+    <div class="tab-content">
+      {#if activeTab === 'basic'}
+        <div class="form-section">
+          <div class="form-group">
+            <label for="award-id">Award ID</label>
+            <input
+              id="award-id"
+              type="text"
+              value={formData.id}
+              disabled
+              placeholder="e.g., dxcc, was, dld"
+            />
+            <small>ID cannot be changed</small>
+          </div>
+
+          <div class="form-group">
+            <label for="award-name">Award Name *</label>
+            <input
+              id="award-name"
+              type="text"
+              bind:value={formData.name}
+              placeholder="e.g., DXCC, Worked All States"
+              required
+            />
+          </div>
+
+          <div class="form-group">
+            <label for="award-description">Short Description *</label>
+            <input
+              id="award-description"
+              type="text"
+              bind:value={formData.description}
+              placeholder="Brief description (1 line)"
+              required
+            />
+          </div>
+
+          <div class="form-group">
+            <label for="award-caption">Detailed Caption *</label>
+            <textarea
+              id="award-caption"
+              bind:value={formData.caption}
+              placeholder="Full explanation of the award requirements"
+              rows="4"
+              required
+            ></textarea>
+          </div>
+
+          <div class="form-group">
+            <label for="award-category">Category *</label>
+            <input
+              id="award-category"
+              type="text"
+              bind:value={formData.category}
+              placeholder="e.g., dxcc, darc, vucc"
+              required
+            />
+            <small>Category for grouping awards (e.g., dxcc, darc, vucc, was, special)</small>
+          </div>
+        </div>
+      {/if}
+
+      {#if activeTab === 'modeGroups'}
+        <div class="form-section">
+          <h2>Mode Groups</h2>
+          <p class="help-text">Define mode groups for filtering in the award detail view. This is optional.</p>
+
+          {#if Object.keys(formData.modeGroups || {}).length > 0}
+            <div class="mode-groups-list">
+              {#each Object.entries(formData.modeGroups || {}) as [name, modes]}
+                <div class="mode-group-item">
+                  <div class="mode-group-header">
+                    <strong>{name}</strong>
+                    <button class="btn-remove" on:click={() => removeModeGroup(name)}>Remove</button>
+                  </div>
+                  <div class="mode-group-modes">
+                    {modes.join(', ')}
+                  </div>
+                </div>
+              {/each}
+            </div>
+          {:else}
+            <p class="empty-state">No mode groups defined yet.</p>
+          {/if}
+
+          <div class="add-mode-group">
+            <h3>Add Mode Group</h3>
+            <div class="form-group">
+              <label>Group Name</label>
+              <input type="text" bind:value={newModeGroupName} placeholder="e.g., Digi-Modes" />
+            </div>
+            <div class="form-group">
+              <label>Modes</label>
+              <div class="mode-selector">
+                {#each ALL_MODES as mode}
+                  <label class="mode-checkbox">
+                    <input
+                      type="checkbox"
+                      bind:group={newModeGroupModes}
+                      value={mode}
+                    />
+                    {mode}
+                  </label>
+                {/each}
+              </div>
+            </div>
+            <button class="btn btn-secondary" on:click={addModeGroup}>Add Mode Group</button>
+          </div>
+        </div>
+      {/if}
+
+      {#if activeTab === 'rules'}
+        <div class="form-section">
+          <h2>Award Rules</h2>
+
+          <div class="form-group">
+            <label for="rule-type">Rule Type *</label>
+            <select id="rule-type" bind:value={formData.rules.type}>
+              <option value="entity">Entity (count unique entities)</option>
+              <option value="dok">DOK (count unique DOK/band/mode)</option>
+              <option value="points">Points (sum points from stations)</option>
+              <option value="filtered">Filtered (base rule with filters)</option>
+              <option value="counter">Counter (count QSOs or callsigns)</option>
+            </select>
+          </div>
+
+          {#if formData.rules.type === 'entity'}
+            <div class="rule-config">
+              <h3>Entity Rule Configuration</h3>
+
+              <div class="form-group">
+                <label>Entity Type *</label>
+                <select bind:value={formData.rules.entityType}>
+                  <option value="">Select entity type</option>
+                  <option value="dxcc">DXCC Entity</option>
+                  <option value="state">State</option>
+                  <option value="grid">Grid Square (first 4 chars)</option>
+                  <option value="callsign">Callsign</option>
+                </select>
+              </div>
+
+              <div class="form-group">
+                <label>Target *</label>
+                <input type="number" min="1" bind:value={formData.rules.target} />
+              </div>
+
+              <div class="form-group">
+                <label>Display Field (optional)</label>
+                <input
+                  type="text"
+                  bind:value={formData.rules.displayField}
+                  placeholder="e.g., entity, state, grid"
+                />
+                <small>Field to display as entity name (defaults to entity value)</small>
+              </div>
+
+              <div class="form-group">
+                <label>
+                  <input type="checkbox" bind:checked={formData.rules.satellite_only} />
+                  Satellite Only (only count QSOs with satName)
+                </label>
+              </div>
+
+              <div class="form-group">
+                <label>Allowed Bands (optional)</label>
+                <div class="bands-selector">
+                  {#each ALL_BANDS as band}
+                    <label class="band-checkbox">
+                      <input
+                        type="checkbox"
+                        bind:group={formData.rules.allowed_bands}
+                        value={band}
+                      />
+                      {band}
+                    </label>
+                  {/each}
+                </div>
+                <small>Leave empty to allow all bands</small>
+              </div>
+            </div>
+          {:else if formData.rules.type === 'dok'}
+            <div class="rule-config">
+              <h3>DOK Rule Configuration</h3>
+
+              <div class="form-group">
+                <label>Target *</label>
+                <input type="number" min="1" bind:value={formData.rules.target} />
+              </div>
+
+              <div class="form-group">
+                <label>Display Field (optional)</label>
+                <input
+                  type="text"
+                  bind:value={formData.rules.displayField}
+                  placeholder="e.g., darcDok"
+                />
+              </div>
+
+              <div class="info-box">
+                DOK rules count unique (DOK, band, mode) combinations with DCL confirmation.
+              </div>
+            </div>
+          {:else if formData.rules.type === 'points'}
+            <div class="rule-config">
+              <h3>Points Rule Configuration</h3>
+
+              <div class="form-group">
+                <label>Target (points required) *</label>
+                <input type="number" min="1" bind:value={formData.rules.target} />
+              </div>
+
+              <div class="form-group">
+                <label>Count Mode *</label>
+                <select bind:value={formData.rules.countMode}>
+                  <option value="perStation">Per Station (each station once)</option>
+                  <option value="perBandMode">Per Band/Mode (per station per band/mode)</option>
+                  <option value="perQso">Per QSO (each confirmed QSO)</option>
+                </select>
+              </div>
+
+              <div class="form-group">
+                <label>Stations *</label>
+                <div class="stations-editor">
+                  {#if formData.rules.stations && formData.rules.stations.length > 0}
+                    {#each formData.rules.stations as station, i}
+                      <div class="station-row">
+                        <input
+                          type="text"
+                          bind:value={station.callsign}
+                          placeholder="Callsign"
+                        />
+                        <input
+                          type="number"
+                          min="1"
+                          bind:value={station.points}
+                          placeholder="Points"
+                        />
+                        <button
+                          class="btn-remove"
+                          on:click={() => formData.rules.stations.splice(i, 1)}
+                        >
+                          Remove
+                        </button>
+                      </div>
+                    {/each}
+                  {:else}
+                    <p class="empty-state">No stations defined.</p>
+                  {/if}
+                  <button
+                    class="btn btn-secondary"
+                    on:click={() => {
+                      if (!formData.rules.stations) formData.rules.stations = [];
+                      formData.rules.stations.push({ callsign: '', points: 1 });
+                    }}
+                  >
+                    Add Station
+                  </button>
+                </div>
+              </div>
+            </div>
+          {:else if formData.rules.type === 'filtered'}
+            <div class="rule-config">
+              <h3>Filtered Rule Configuration</h3>
+
+              <div class="info-box">
+                Filtered rules use a base rule with additional filter conditions.
+              </div>
+
+              <div class="form-group">
+                <label>Base Rule Type *</label>
+                <select
+                  value={formData.rules.baseRule?.type || 'entity'}
+                  on:change={(e) => {
+                    formData.rules.baseRule = { type: e.target.value };
+                  }}
+                >
+                  <option value="entity">Entity</option>
+                </select>
+              </div>
+
+              {#if formData.rules.baseRule?.type === 'entity'}
+                <div class="base-rule-config">
+                  <div class="form-group">
+                    <label>Entity Type *</label>
+                    <select bind:value={formData.rules.baseRule.entityType}>
+                      <option value="dxcc">DXCC Entity</option>
+                      <option value="state">State</option>
+                      <option value="grid">Grid Square</option>
+                      <option value="callsign">Callsign</option>
+                    </select>
+                  </div>
+
+                  <div class="form-group">
+                    <label>Target *</label>
+                    <input type="number" min="1" bind:value={formData.rules.baseRule.target} />
+                  </div>
+                </div>
+              {/if}
+            </div>
+          {:else if formData.rules.type === 'counter'}
+            <div class="rule-config">
+              <h3>Counter Rule Configuration</h3>
+
+              <div class="form-group">
+                <label>Target *</label>
+                <input type="number" min="1" bind:value={formData.rules.target} />
+              </div>
+
+              <div class="form-group">
+                <label>Count By *</label>
+                <select bind:value={formData.rules.countBy}>
+                  <option value="qso">Count QSOs</option>
+                  <option value="callsign">Count unique callsigns</option>
+                </select>
+              </div>
+
+              <div class="form-group">
+                <label>Display Field (optional)</label>
+                <input
+                  type="text"
+                  bind:value={formData.rules.displayField}
+                  placeholder="e.g., callsign"
+                />
+              </div>
+            </div>
+          {/if}
+
+          <!-- Filters section (common to all rule types) -->
+          <div class="filters-section">
+            <h3>Filters</h3>
+            <p class="help-text">Add optional filters to restrict which QSOs count toward this award.</p>
+            <FilterBuilder
+              bind:filters={formData.rules.filters}
+              onChange={handleFiltersChange}
+            />
+          </div>
+        </div>
+      {/if}
+    </div>
+  </div>
+
+  {#if showTestModal && awardId}
+    <TestAwardModal
+      awardId={awardId}
+      awardDefinition={formData}
+      onClose={() => showTestModal = false}
+    />
+  {/if}
+{/if}
+
+<style>
+  .award-editor {
+    padding: 2rem;
+    max-width: 1200px;
+    margin: 0 auto;
+  }
+
+  .loading {
+    text-align: center;
+    padding: 3rem;
+    font-size: 1.2rem;
+    color: #666;
+  }
+
+  .header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1.5rem;
+    flex-wrap: wrap;
+    gap: 1rem;
+  }
+
+  .header h1 {
+    margin: 0;
+    color: #333;
+  }
+
+  .header-actions {
+    display: flex;
+    gap: 1rem;
+  }
+
+  .error, .validation-errors {
+    background-color: #fee;
+    border: 1px solid #fcc;
+    padding: 1rem;
+    border-radius: 4px;
+    color: #c00;
+    margin-bottom: 1rem;
+  }
+
+  .validation-warnings {
+    background-color: #fff3cd;
+    border: 1px solid #ffc107;
+    padding: 1rem;
+    border-radius: 4px;
+    color: #856404;
+    margin-bottom: 1rem;
+  }
+
+  .validation-errors h3, .validation-warnings h3 {
+    margin: 0 0 0.5rem 0;
+    font-size: 1rem;
+  }
+
+  .validation-errors ul, .validation-warnings ul {
+    margin: 0;
+    padding-left: 1.5rem;
+  }
+
+  .tabs {
+    display: flex;
+    gap: 0.5rem;
+    margin-bottom: 1.5rem;
+    border-bottom: 2px solid #ddd;
+  }
+
+  .tab {
+    padding: 0.75rem 1.5rem;
+    background: none;
+    border: none;
+    cursor: pointer;
+    font-size: 1rem;
+    font-weight: 500;
+    color: #666;
+    position: relative;
+    top: 2px;
+  }
+
+  .tab:hover {
+    color: #333;
+  }
+
+  .tab.active {
+    color: #667eea;
+    border-bottom: 2px solid #667eea;
+  }
+
+  .form-section {
+    background: white;
+    padding: 2rem;
+    border-radius: 8px;
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+  }
+
+  .form-group {
+    margin-bottom: 1.5rem;
+  }
+
+  .form-group label {
+    display: block;
+    font-weight: 500;
+    margin-bottom: 0.5rem;
+    color: #333;
+  }
+
+  .form-group input[type="text"],
+  .form-group input[type="number"],
+  .form-group select,
+  .form-group textarea {
+    width: 100%;
+    padding: 0.6rem;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    font-size: 1rem;
+  }
+
+  .form-group textarea {
+    font-family: inherit;
+    resize: vertical;
+  }
+
+  .form-group small {
+    display: block;
+    margin-top: 0.25rem;
+    color: #888;
+    font-size: 0.85rem;
+  }
+
+  .btn {
+    padding: 0.6rem 1.2rem;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    font-weight: 500;
+    transition: all 0.2s;
+  }
+
+  .btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+
+  .btn-primary {
+    background-color: #667eea;
+    color: white;
+  }
+
+  .btn-primary:hover:not(:disabled) {
+    background-color: #5568d3;
+  }
+
+  .btn-secondary {
+    background-color: #6c757d;
+    color: white;
+  }
+
+  .btn-secondary:hover {
+    background-color: #5a6268;
+  }
+
+  .btn-remove {
+    background-color: #e74c3c;
+    color: white;
+    padding: 0.4rem 0.8rem;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 0.85rem;
+  }
+
+  .btn-remove:hover {
+    background-color: #c0392b;
+  }
+
+  .help-text {
+    color: #666;
+    font-style: italic;
+    margin-bottom: 1rem;
+  }
+
+  .mode-groups-list {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+    margin-bottom: 2rem;
+  }
+
+  .mode-group-item {
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 1rem;
+    background: #f9f9f9;
+  }
+
+  .mode-group-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 0.5rem;
+  }
+
+  .mode-group-modes {
+    color: #666;
+    font-size: 0.9rem;
+  }
+
+  .add-mode-group {
+    border-top: 1px solid #ddd;
+    padding-top: 2rem;
+  }
+
+  .add-mode-group h3 {
+    margin-bottom: 1rem;
+  }
+
+  .mode-selector, .bands-selector {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(100px, 1fr));
+    gap: 0.5rem;
+    margin-top: 0.5rem;
+  }
+
+  .mode-checkbox, .band-checkbox {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.25rem;
+    cursor: pointer;
+  }
+
+  .mode-checkbox input, .band-checkbox input {
+    cursor: pointer;
+  }
+
+  .rule-config {
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 1.5rem;
+    margin-bottom: 1.5rem;
+    background: #f9f9f9;
+  }
+
+  .rule-config h3 {
+    margin-top: 0;
+    margin-bottom: 1rem;
+  }
+
+  .info-box {
+    background-color: #e3f2fd;
+    border-left: 4px solid #2196f3;
+    padding: 1rem;
+    margin-top: 1rem;
+    color: #0d47a1;
+  }
+
+  .stations-editor {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+
+  .station-row {
+    display: flex;
+    gap: 0.5rem;
+    align-items: center;
+  }
+
+  .station-row input:first-child {
+    flex: 2;
+  }
+
+  .station-row input:last-child {
+    flex: 1;
+    width: 100px;
+  }
+
+  .base-rule-config {
+    padding-left: 1rem;
+    border-left: 3px solid #ddd;
+  }
+
+  .filters-section {
+    margin-top: 2rem;
+    padding-top: 2rem;
+    border-top: 1px solid #ddd;
+  }
+
+  .empty-state {
+    color: #888;
+    font-style: italic;
+    text-align: center;
+    padding: 1rem;
+  }
+
+  @media (max-width: 768px) {
+    .award-editor {
+      padding: 1rem;
+    }
+
+    .header {
+      flex-direction: column;
+      align-items: stretch;
+    }
+
+    .header-actions {
+      flex-direction: column;
+    }
+
+    .mode-selector, .bands-selector {
+      grid-template-columns: repeat(auto-fill, minmax(80px, 1fr));
+    }
+
+    .station-row {
+      flex-direction: column;
+      align-items: stretch;
+    }
+
+    .station-row input {
+      width: 100%;
+    }
+  }
+</style>
diff --git a/src/frontend/src/routes/admin/awards/components/FilterBuilder.svelte b/src/frontend/src/routes/admin/awards/components/FilterBuilder.svelte
new file mode 100644
index 0000000..8c5d15d
--- /dev/null
+++ b/src/frontend/src/routes/admin/awards/components/FilterBuilder.svelte
@@ -0,0 +1,483 @@
+<script>
+  import { createEventDispatcher } from 'svelte';
+
+  export let filters = null;
+  export let onChange = () => {};
+
+  const dispatch = createEventDispatcher();
+
+  const ALL_FIELDS = [
+    { value: 'band', label: 'Band' },
+    { value: 'mode', label: 'Mode' },
+    { value: 'callsign', label: 'Callsign' },
+    { value: 'entity', label: 'Entity (Country)' },
+    { value: 'entityId', label: 'Entity ID' },
+    { value: 'state', label: 'State' },
+    { value: 'grid', label: 'Grid Square' },
+    { value: 'satName', label: 'Satellite Name' },
+    { value: 'satellite', label: 'Is Satellite QSO' },
+  ];
+
+  const OPERATORS = [
+    { value: 'eq', label: 'Equals', needsArray: false },
+    { value: 'ne', label: 'Not Equals', needsArray: false },
+    { value: 'in', label: 'In', needsArray: true },
+    { value: 'nin', label: 'Not In', needsArray: true },
+    { value: 'contains', label: 'Contains', needsArray: false },
+  ];
+
+  const BAND_OPTIONS = ['160m', '80m', '60m', '40m', '30m', '20m', '17m', '15m', '12m', '10m', '6m', '2m', '70cm', '23cm', '13cm', '9cm', '6cm', '3cm'];
+  const MODE_OPTIONS = ['CW', 'SSB', 'AM', 'FM', 'RTTY', 'PSK31', 'FT8', 'FT4', 'JT65', 'JT9', 'MFSK', 'Q65', 'JS8', 'FSK441', 'ISCAT', 'JT6M', 'MSK144'];
+
+  // Add a new filter
+  function addFilter() {
+    if (!filters) {
+      filters = { operator: 'AND', filters: [] };
+    }
+    if (!filters.filters) {
+      filters.filters = [];
+    }
+    filters.filters.push({
+      field: 'band',
+      operator: 'eq',
+      value: ''
+    });
+    updateFilters();
+  }
+
+  // Add a nested filter group
+  function addFilterGroup() {
+    if (!filters) {
+      filters = { operator: 'AND', filters: [] };
+    }
+    if (!filters.filters) {
+      filters.filters = [];
+    }
+    filters.filters.push({
+      operator: 'AND',
+      filters: []
+    });
+    updateFilters();
+  }
+
+  // Remove a filter at index
+  function removeFilter(index) {
+    if (filters && filters.filters) {
+      filters.filters.splice(index, 1);
+      // If no filters left, set to null
+      if (filters.filters.length === 0) {
+        filters = null;
+      }
+      updateFilters();
+    }
+  }
+
+  // Update a filter at index
+  function updateFilter(index, key, value) {
+    if (filters && filters.filters) {
+      filters.filters[index][key] = value;
+      updateFilters();
+    }
+  }
+
+  // Update filter operator (AND/OR)
+  function updateOperator(operator) {
+    if (filters) {
+      filters.operator = operator;
+      updateFilters();
+    }
+  }
+
+  // Get input type based on field and operator
+  function getInputType(field, operator) {
+    const opConfig = OPERATORS.find(o => o.value === operator);
+    const needsArray = opConfig?.needsArray || false;
+
+    if (field === 'band' && needsArray) return 'band-multi';
+    if (field === 'band') return 'band';
+    if (field === 'mode' && needsArray) return 'mode-multi';
+    if (field === 'mode') return 'mode';
+    if (field === 'satellite') return 'boolean';
+    if (needsArray) return 'text-array';
+    return 'text';
+  }
+
+  // Notify parent of changes
+  function updateFilters() {
+    // Deep clone to avoid reactivity issues
+    const cloned = filters ? JSON.parse(JSON.stringify(filters)) : null;
+    onChange(cloned);
+    dispatch('change', cloned);
+  }
+
+  // Check if a filter is a group (has nested filters)
+  function isFilterGroup(filter) {
+    return filter && typeof filter === 'object' && filter.filters !== undefined;
+  }
+</script>
+
+<div class="filter-builder">
+  {#if !filters || !filters.filters || filters.filters.length === 0}
+    <div class="no-filters">
+      <p>No filters defined. All QSOs will be evaluated.</p>
+      <button class="btn btn-secondary" on:click={addFilter}>Add Filter</button>
+    </div>
+  {:else}
+    <div class="filter-group">
+      <div class="filter-group-header">
+        <h4>Filters</h4>
+        <div class="operator-selector">
+          <label>
+            <input
+              type="radio"
+              bind:group={filters.operator}
+              value="AND"
+              on:change={() => updateOperator('AND')}
+            />
+            AND
+          </label>
+          <label>
+            <input
+              type="radio"
+              bind:group={filters.operator}
+              value="OR"
+              on:change={() => updateOperator('OR')}
+            />
+            OR
+          </label>
+        </div>
+      </div>
+
+      <div class="filter-list">
+        {#each filters.filters as filter, index}
+          <div class="filter-item">
+            {#if isFilterGroup(filter)}
+              <!-- Nested filter group -->
+              <div class="nested-filter-group">
+                <div class="nested-header">
+                  <span class="group-label">Group ({filter.operator})</span>
+                  <button class="btn-remove" on:click={() => removeFilter(index)}>Remove</button>
+                </div>
+                <svelte:self filters={filter} onChange={(nested) => updateFilter(index, nested)} />
+              </div>
+            {:else}
+              <!-- Single filter -->
+              <div class="single-filter">
+                <select
+                  class="field-select"
+                  bind:value={filter.field}
+                  on:change={() => updateFilter(index, 'field', filter.field)}
+                >
+                  {#each ALL_FIELDS as field}
+                    <option value={field.value}>{field.label}</option>
+                  {/each}
+                </select>
+
+                <select
+                  class="operator-select"
+                  bind:value={filter.operator}
+                  on:change={() => updateFilter(index, 'operator', filter.operator)}
+                >
+                  {#each OPERATORS as op}
+                    <option value={op.value}>{op.label}</option>
+                  {/each}
+                </select>
+
+                <div class="filter-value">
+                  {#if getInputType(filter.field, filter.operator) === 'band'}
+                    <select bind:value={filter.value} on:change={() => updateFilter(index, 'value', filter.value)}>
+                      <option value="">Select band</option>
+                      {#each BAND_OPTIONS as band}
+                        <option value={band}>{band}</option>
+                      {/each}
+                    </select>
+                  {:else if getInputType(filter.field, filter.operator) === 'band-multi'}
+                    <div class="multi-select">
+                      {#each BAND_OPTIONS as band}
+                        <label class="checkbox-option">
+                          <input
+                            type="checkbox"
+                            checked={Array.isArray(filter.value) && filter.value.includes(band)}
+                            on:change={(e) => {
+                              if (!Array.isArray(filter.value)) filter.value = [];
+                              if (e.target.checked) {
+                                filter.value = [...filter.value, band];
+                              } else {
+                                filter.value = filter.value.filter(v => v !== band);
+                              }
+                              updateFilter(index, 'value', filter.value);
+                            }}
+                          />
+                          {band}
+                        </label>
+                      {/each}
+                    </div>
+                  {:else if getInputType(filter.field, filter.operator) === 'mode'}
+                    <select bind:value={filter.value} on:change={() => updateFilter(index, 'value', filter.value)}>
+                      <option value="">Select mode</option>
+                      {#each MODE_OPTIONS as mode}
+                        <option value={mode}>{mode}</option>
+                      {/each}
+                    </select>
+                  {:else if getInputType(filter.field, filter.operator) === 'mode-multi'}
+                    <div class="multi-select">
+                      {#each MODE_OPTIONS as mode}
+                        <label class="checkbox-option">
+                          <input
+                            type="checkbox"
+                            checked={Array.isArray(filter.value) && filter.value.includes(mode)}
+                            on:change={(e) => {
+                              if (!Array.isArray(filter.value)) filter.value = [];
+                              if (e.target.checked) {
+                                filter.value = [...filter.value, mode];
+                              } else {
+                                filter.value = filter.value.filter(v => v !== mode);
+                              }
+                              updateFilter(index, 'value', filter.value);
+                            }}
+                          />
+                          {mode}
+                        </label>
+                      {/each}
+                    </div>
+                  {:else if getInputType(filter.field, filter.operator) === 'boolean'}
+                    <select bind:value={filter.value} on:change={() => updateFilter(index, 'value', filter.value)}>
+                      <option value="true">Yes</option>
+                      <option value="false">No</option>
+                    </select>
+                  {:else if getInputType(filter.field, filter.operator) === 'text-array'}
+                    <input
+                      type="text"
+                      placeholder="comma-separated values"
+                      value={Array.isArray(filter.value) ? filter.value.join(', ') : filter.value}
+                      on:change={(e) => {
+                        const values = e.target.value.split(',').map(v => v.trim()).filter(v => v);
+                        updateFilter(index, 'value', values);
+                      }}
+                    />
+                  {:else}
+                    <input
+                      type="text"
+                      placeholder="Value"
+                      bind:value={filter.value}
+                      on:change={() => updateFilter(index, 'value', filter.value)}
+                    />
+                  {/if}
+                </div>
+
+                <button class="btn-remove" on:click={() => removeFilter(index)}>Remove</button>
+              </div>
+            {/if}
+          </div>
+        {/each}
+      </div>
+
+      <div class="filter-actions">
+        <button class="btn btn-secondary" on:click={addFilter}>Add Filter</button>
+        <button class="btn btn-secondary" on:click={addFilterGroup}>Add Filter Group</button>
+        <button class="btn btn-danger" on:click={() => { filters = null; updateFilters(); }}>Clear All Filters</button>
+      </div>
+    </div>
+  {/if}
+</div>
+
+<style>
+  .filter-builder {
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 1.5rem;
+    background: #fafafa;
+  }
+
+  .no-filters {
+    text-align: center;
+    padding: 1rem;
+    color: #666;
+  }
+
+  .filter-group {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+  }
+
+  .filter-group-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 0.5rem;
+  }
+
+  .filter-group-header h4 {
+    margin: 0;
+    color: #333;
+  }
+
+  .operator-selector {
+    display: flex;
+    gap: 1rem;
+  }
+
+  .operator-selector label {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    cursor: pointer;
+  }
+
+  .filter-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.75rem;
+  }
+
+  .filter-item {
+    background: white;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 1rem;
+  }
+
+  .single-filter {
+    display: flex;
+    gap: 0.5rem;
+    align-items: center;
+    flex-wrap: wrap;
+  }
+
+  .single-filter select,
+  .single-filter input {
+    padding: 0.5rem;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    font-size: 0.9rem;
+  }
+
+  .field-select {
+    min-width: 150px;
+  }
+
+  .operator-select {
+    min-width: 120px;
+  }
+
+  .filter-value {
+    flex: 1;
+    min-width: 200px;
+  }
+
+  .filter-value select,
+  .filter-value input {
+    width: 100%;
+  }
+
+  .nested-filter-group {
+    border-left: 3px solid #667eea;
+    padding-left: 1rem;
+  }
+
+  .nested-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 0.5rem;
+  }
+
+  .group-label {
+    font-weight: 500;
+    color: #667eea;
+  }
+
+  .multi-select {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+  }
+
+  .checkbox-option {
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 0.25rem 0.5rem;
+    background: #f5f5f5;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 0.85rem;
+  }
+
+  .checkbox-option input {
+    cursor: pointer;
+  }
+
+  .btn-remove {
+    background-color: #dc3545;
+    color: white;
+    padding: 0.4rem 0.8rem;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 0.85rem;
+  }
+
+  .btn-remove:hover {
+    background-color: #c82333;
+  }
+
+  .filter-actions {
+    display: flex;
+    gap: 0.5rem;
+    flex-wrap: wrap;
+    margin-top: 1rem;
+    padding-top: 1rem;
+    border-top: 1px solid #ddd;
+  }
+
+  .btn {
+    padding: 0.5rem 1rem;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    font-weight: 500;
+    font-size: 0.9rem;
+  }
+
+  .btn-secondary {
+    background-color: #6c757d;
+    color: white;
+  }
+
+  .btn-secondary:hover {
+    background-color: #5a6268;
+  }
+
+  .btn-danger {
+    background-color: #dc3545;
+    color: white;
+  }
+
+  .btn-danger:hover {
+    background-color: #c82333;
+  }
+
+  @media (max-width: 768px) {
+    .single-filter {
+      flex-direction: column;
+      align-items: stretch;
+    }
+
+    .field-select,
+    .operator-select,
+    .filter-value {
+      width: 100%;
+      min-width: unset;
+    }
+
+    .filter-actions {
+      flex-direction: column;
+    }
+
+    .filter-actions button {
+      width: 100%;
+    }
+  }
+</style>
diff --git a/src/frontend/src/routes/admin/awards/components/TestAwardModal.svelte b/src/frontend/src/routes/admin/awards/components/TestAwardModal.svelte
new file mode 100644
index 0000000..76a02a0
--- /dev/null
+++ b/src/frontend/src/routes/admin/awards/components/TestAwardModal.svelte
@@ -0,0 +1,836 @@
+<script>
+  import { onMount } from 'svelte';
+  import { awardsAdminAPI, adminAPI } from '$lib/api.js';
+
+  export let awardId = null;
+  export let awardDefinition = null;
+  export let onClose = () => {};
+
+  let loading = false;
+  let testResult = null;
+  let testError = null;
+  let users = [];
+  let selectedUserId = null;
+
+  // Extended validation results
+  let logicValidation = null;
+
+  onMount(async () => {
+    await loadUsers();
+    if (awardDefinition) {
+      performLogicValidation();
+    }
+  });
+
+  async function loadUsers() {
+    try {
+      const data = await adminAPI.getUsers();
+      users = data.users || [];
+    } catch (err) {
+      console.error('Failed to load users:', err);
+    }
+  }
+
+  async function runTest() {
+    if (!awardId) return;
+
+    loading = true;
+    testResult = null;
+    testError = null;
+
+    try {
+      // Pass awardDefinition for unsaved awards (testing during create/edit)
+      const data = await awardsAdminAPI.test(awardId, selectedUserId, awardDefinition);
+      testResult = data;
+    } catch (err) {
+      testError = err.message;
+    } finally {
+      loading = false;
+    }
+  }
+
+  // Perform deep logic validation on award definition
+  function performLogicValidation() {
+    if (!awardDefinition) return;
+
+    const issues = {
+      errors: [],
+      warnings: [],
+      info: []
+    };
+
+    const rules = awardDefinition.rules;
+
+    // 1. Check for impossible filter combinations
+    if (rules.filters) {
+      const impossibleFilterCombos = checkImpossibleFilters(rules.filters, rules);
+      issues.errors.push(...impossibleFilterCombos.errors);
+      issues.warnings.push(...impossibleFilterCombos.warnings);
+    }
+
+    // 2. Check for redundancy
+    const redundancies = checkRedundancies(rules);
+    issues.warnings.push(...redundancies.warnings);
+    issues.info.push(...redundancies.info);
+
+    // 3. Check for logical contradictions
+    const contradictions = checkContradictions(rules);
+    issues.errors.push(...contradictions.errors);
+    issues.warnings.push(...contradictions.warnings);
+
+    // 4. Check for edge cases that might cause issues
+    const edgeCases = checkEdgeCases(rules);
+    issues.info.push(...edgeCases);
+
+    // 5. Provide helpful suggestions
+    const suggestions = provideSuggestions(rules);
+    issues.info.push(...suggestions);
+
+    logicValidation = issues;
+  }
+
+  // Check for impossible filter combinations
+  function checkImpossibleFilters(filters, rules) {
+    const errors = [];
+    const warnings = [];
+
+    function analyze(filterNode, depth = 0) {
+      if (!filterNode || !filterNode.filters) return;
+
+      // Group filters by field to check for contradictions
+      const fieldFilters = {};
+      for (const f of filterNode.filters) {
+        if (f.field) {
+          if (!fieldFilters[f.field]) fieldFilters[f.field] = [];
+          fieldFilters[f.field].push(f);
+        } else if (f.filters) {
+          analyze(f, depth + 1);
+        }
+      }
+
+      // Check for contradictions in AND groups
+      if (filterNode.operator === 'AND') {
+        for (const [field, fieldFiltersList] of Object.entries(fieldFilters)) {
+          // Check for direct contradictions: field=X AND field=Y
+          const eqFilters = fieldFiltersList.filter(f => f.operator === 'eq');
+          const neFilters = fieldFiltersList.filter(f => f.operator === 'ne');
+
+          for (const eq1 of eqFilters) {
+            for (const eq2 of eqFilters) {
+              if (eq1 !== eq2 && eq1.value !== eq2.value) {
+                errors.push(`Impossible filter: ${field} cannot be both "${eq1.value}" AND "${eq2.value}"`);
+              }
+            }
+
+            for (const ne of neFilters) {
+              if (eq1.value === ne.value) {
+                errors.push(`Impossible filter: ${field} cannot be "${eq1.value}" AND not "${ne.value}" at the same time`);
+              }
+            }
+          }
+
+          // Check for in/nin contradictions
+          const inFilters = fieldFiltersList.filter(f => f.operator === 'in');
+          const ninFilters = fieldFiltersList.filter(f => f.operator === 'nin');
+
+          for (const inF of inFilters) {
+            if (Array.isArray(inF.value)) {
+              for (const ninF of ninFilters) {
+                if (Array.isArray(ninF.value)) {
+                  const overlap = inF.value.filter(v => ninF.value.includes(v));
+                  if (overlap.length > 0 && overlap.length === inF.value.length) {
+                    errors.push(`Impossible filter: ${field} must be in ${inF.value.join(', ')} AND not in ${overlap.join(', ')}`);
+                  } else if (overlap.length > 0) {
+                    warnings.push(`Suspicious filter: ${field} filter has overlapping values: ${overlap.join(', ')}`);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      // Check for redundant OR groups (field=X OR field=X)
+      if (filterNode.operator === 'OR') {
+        for (const [field, fieldFiltersList] of Object.entries(fieldFilters)) {
+          const eqFilters = fieldFiltersList.filter(f => f.operator === 'eq');
+
+          for (let i = 0; i < eqFilters.length; i++) {
+            for (let j = i + 1; j < eqFilters.length; j++) {
+              if (eqFilters[i].value === eqFilters[j].value) {
+                warnings.push(`Redundant filter: ${field}="${eqFilters[i].value}" appears multiple times in OR group`);
+              }
+            }
+          }
+        }
+      }
+    }
+
+    analyze(filters);
+    return { errors, warnings };
+  }
+
+  // Check for redundancies in the definition
+  function checkRedundancies(rules) {
+    const warnings = [];
+    const info = [];
+
+    // Check if satellite_only is redundant when filters already check for satellite
+    if (rules.satellite_only && rules.filters) {
+      const satFilter = findSatelliteFilter(rules.filters);
+      if (satFilter && satFilter.operator === 'eq' && satFilter.value === true) {
+        info.push('satellite_only=true is set, but filters already check for satellite QSOs. The filter is redundant.');
+      }
+    }
+
+    // Check if allowed_bands makes filters redundant
+    if (rules.allowed_bands && rules.allowed_bands.length > 0 && rules.filters) {
+      const bandFilters = extractBandFilters(rules.filters);
+      for (const bf of bandFilters) {
+        if (bf.operator === 'in' && Array.isArray(bf.value)) {
+          const allCovered = bf.value.every(b => rules.allowed_bands.includes(b));
+          if (allCovered) {
+            info.push(`allowed_bands already includes all bands in the filter. Consider removing the filter.`);
+          }
+        }
+      }
+    }
+
+    // Check if displayField matches the default for the entity type
+    if (rules.entityType && rules.displayField) {
+      const defaults = {
+        'dxcc': 'entity',
+        'state': 'state',
+        'grid': 'grid',
+        'callsign': 'callsign'
+      };
+      if (defaults[rules.entityType] === rules.displayField) {
+        info.push(`displayField="${rules.displayField}" is the default for entityType="${rules.entityType}". It can be omitted.`);
+      }
+    }
+
+    return { warnings, info };
+  }
+
+  // Check for logical contradictions
+  function checkContradictions(rules) {
+    const errors = [];
+    const warnings = [];
+
+    // Check satellite_only with HF-only allowed_bands
+    if (rules.satellite_only && rules.allowed_bands) {
+      const hfBands = ['160m', '80m', '60m', '40m', '30m', '20m', '17m', '15m', '12m', '10m'];
+      const hasHfOnly = rules.allowed_bands.length > 0 &&
+        rules.allowed_bands.every(b => hfBands.includes(b));
+
+      if (hasHfOnly) {
+        warnings.push('satellite_only is set but allowed_bands only includes HF bands. Satellite work typically uses VHF/UHF bands.');
+      }
+    }
+
+    // For DOK rules, verify confirmation type
+    if (rules.type === 'dok' && rules.confirmationType && rules.confirmationType !== 'dcl') {
+      warnings.push('DOK awards typically require DCL confirmation (confirmationType="dcl").');
+    }
+
+    // Check for impossible targets
+    if (rules.target) {
+      if (rules.type === 'entity' && rules.entityType === 'dxcc' && rules.target > 340) {
+        warnings.push(`Target (${rules.target}) exceeds the total number of DXCC entities (~340).`);
+      }
+
+      if (rules.type === 'dok' && rules.target > 700) {
+        info.push(`Target (${rules.target}) is high. There are ~700 DOKs in Germany.`);
+      }
+    }
+
+    return { errors, warnings };
+  }
+
+  // Check for edge cases
+  function checkEdgeCases(rules) {
+    const info = [];
+
+    if (rules.filters) {
+      const filterCount = countFilters(rules.filters);
+      if (filterCount > 10) {
+        info.push(`Complex filter structure (${filterCount} filters). Consider simplifying for better performance.`);
+      }
+    }
+
+    if (rules.modeGroups) {
+      const totalModes = Object.values(rules.modeGroups).reduce((sum, modes) => sum + (modes?.length || 0), 0);
+      if (totalModes > 20) {
+        info.push('Many mode groups defined. Make sure users understand the grouping logic.');
+      }
+    }
+
+    if (rules.type === 'points' && rules.stations) {
+      const totalPossiblePoints = rules.stations.reduce((sum, s) => sum + (s.points || 0), 0);
+      if (totalPossiblePoints < rules.target) {
+        info.push(`Even with all stations confirmed, max points (${totalPossiblePoints}) is less than target (${rules.target}). Award is impossible to complete.`);
+      }
+    }
+
+    return info;
+  }
+
+  // Provide helpful suggestions
+  function provideSuggestions(rules) {
+    const info = [];
+
+    // Suggest common award patterns
+    if (rules.type === 'entity' && rules.entityType === 'dxcc' && !rules.allowed_bands) {
+      info.push('Consider adding allowed_bands to restrict to specific bands (e.g., HF only: ["160m", "80m", ...]).');
+    }
+
+    if (rules.type === 'entity' && !rules.modeGroups && ['dxcc', 'dld'].includes(rules.entityType)) {
+      info.push('Consider adding modeGroups to help users filter by mode type (e.g., "Digi-Modes", "Phone-Modes").');
+    }
+
+    if (rules.type === 'dok' && !rules.filters) {
+      info.push('DOK awards can have band/mode filters via the filters property. Consider adding them for specific variations.');
+    }
+
+    return info;
+  }
+
+  // Helper: Find satellite-related filter
+  function findSatelliteFilter(filters, depth = 0) {
+    if (!filters || depth > 5) return null;
+
+    if (filters.field === 'satellite' || filters.field === 'satName') {
+      return filters;
+    }
+
+    if (filters.filters) {
+      for (const f of filters.filters) {
+        const found = findSatelliteFilter(f, depth + 1);
+        if (found) return found;
+      }
+    }
+
+    return null;
+  }
+
+  // Helper: Extract band filters
+  function extractBandFilters(filters, depth = 0) {
+    if (!filters || depth > 5) return [];
+
+    const result = [];
+
+    if (filters.field === 'band') {
+      result.push(filters);
+    }
+
+    if (filters.filters) {
+      for (const f of filters.filters) {
+        result.push(...extractBandFilters(f, depth + 1));
+      }
+    }
+
+    return result;
+  }
+
+  // Helper: Count total filters
+  function countFilters(filters, depth = 0) {
+    if (!filters || depth > 5) return 0;
+
+    let count = 0;
+
+    if (filters.filters) {
+      for (const f of filters.filters) {
+        if (f.filters) {
+          count += 1 + countFilters(f, depth + 1);
+        } else {
+          count += 1;
+        }
+      }
+    }
+
+    return count;
+  }
+
+  function getSeverityClass(type) {
+    switch (type) {
+      case 'error': return 'severity-error';
+      case 'warning': return 'severity-warning';
+      case 'info': return 'severity-info';
+      default: return '';
+    }
+  }
+</script>
+
+{#if logicValidation || testResult || testError}
+  <div class="modal-overlay" on:click={onClose}>
+    <div class="modal-content large" on:click|stopPropagation>
+      <div class="modal-header">
+        <h2>{testResult ? 'Test Results' : 'Award Validation'}{awardId ? `: ${awardId}` : ''}</h2>
+        <button class="close-btn" on:click={onClose}>×</button>
+      </div>
+
+      <div class="modal-body">
+        <!-- Logic Validation Section -->
+        {#if logicValidation && (logicValidation.errors.length > 0 || logicValidation.warnings.length > 0 || logicValidation.info.length > 0)}
+          <div class="validation-section">
+            <h3>Logic Validation</h3>
+
+            {#if logicValidation.errors.length > 0}
+              <div class="validation-block errors">
+                <h4>Errors (must fix)</h4>
+                <ul>
+                  {#each logicValidation.errors as err}
+                    <li class="severity-error">{err}</li>
+                  {/each}
+                </ul>
+              </div>
+            {/if}
+
+            {#if logicValidation.warnings.length > 0}
+              <div class="validation-block warnings">
+                <h4>Warnings</h4>
+                <ul>
+                  {#each logicValidation.warnings as warn}
+                    <li class="severity-warning">{warn}</li>
+                  {/each}
+                </ul>
+              </div>
+            {/if}
+
+            {#if logicValidation.info.length > 0}
+              <div class="validation-block info">
+                <h4>Suggestions</h4>
+                <ul>
+                  {#each logicValidation.info as info}
+                    <li class="severity-info">{info}</li>
+                  {/each}
+                </ul>
+              </div>
+            {/if}
+
+            {#if logicValidation.errors.length === 0 && logicValidation.warnings.length === 0}
+              <div class="validation-block success">
+                <p>No issues found. The award definition looks good!</p>
+              </div>
+            {/if}
+          </div>
+        {/if}
+
+        <!-- Test Configuration -->
+        <div class="test-config">
+          <h3>Test Calculation</h3>
+          <p class="help-text">Select a user to test the award calculation with their QSO data.</p>
+
+          <div class="user-selector">
+            <label for="test-user">Test with user:</label>
+            <select id="test-user" bind:value={selectedUserId}>
+              <option value="">-- Select a user --</option>
+              {#each users as user}
+                <option value={user.id}>{user.callsign} ({user.email}) - {user.qsoCount || 0} QSOs</option>
+              {/each}
+            </select>
+          </div>
+
+          <button
+            class="btn btn-primary"
+            on:click={runTest}
+            disabled={loading || !selectedUserId || !awardId}
+          >
+            {loading ? 'Testing...' : 'Run Test'}
+          </button>
+        </div>
+
+        <!-- Test Results -->
+        {#if testError}
+          <div class="test-results error">
+            <h4>Test Failed</h4>
+            <p>{testError}</p>
+          </div>
+        {:else if testResult}
+          <div class="test-results success">
+            <h4>Test Results</h4>
+
+            <div class="result-summary">
+              <div class="result-item">
+                <span class="label">Award:</span>
+                <span class="value">{testResult.award?.name || awardId}</span>
+              </div>
+              <div class="result-item">
+                <span class="label">Worked:</span>
+                <span class="value">{testResult.worked || 0}</span>
+              </div>
+              <div class="result-item">
+                <span class="label">Confirmed:</span>
+                <span class="value confirmed">{testResult.confirmed || 0}</span>
+              </div>
+              <div class="result-item">
+                <span class="label">Target:</span>
+                <span class="value">{testResult.target || 0}</span>
+              </div>
+              <div class="result-item">
+                <span class="label">Progress:</span>
+                <span class="value progress">{testResult.percentage || 0}%</span>
+              </div>
+            </div>
+
+            {#if testResult.warnings && testResult.warnings.length > 0}
+              <div class="result-warnings">
+                <h5>Warnings:</h5>
+                <ul>
+                  {#each testResult.warnings as warning}
+                    <li>{warning}</li>
+                  {/each}
+                </ul>
+              </div>
+            {/if}
+
+            {#if testResult.sampleEntities && testResult.sampleEntities.length > 0}
+              <div class="sample-entities">
+                <h5>Sample Matched Entities (first {testResult.sampleEntities.length}):</h5>
+                <div class="entities-list">
+                  {#each testResult.sampleEntities as entity}
+                    <span class="entity-tag">{entity}</span>
+                  {/each}
+                </div>
+              </div>
+            {:else}
+              <div class="no-matches">
+                <p>No entities matched. Check filters and band/mode restrictions.</p>
+              </div>
+            {/if}
+          </div>
+        {/if}
+      </div>
+
+      <div class="modal-footer">
+        <button class="btn btn-secondary" on:click={onClose}>Close</button>
+      </div>
+    </div>
+  </div>
+{/if}
+
+<style>
+  .modal-overlay {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background-color: rgba(0, 0, 0, 0.5);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    z-index: 1000;
+    padding: 1rem;
+  }
+
+  .modal-content {
+    background: white;
+    border-radius: 8px;
+    max-width: 800px;
+    width: 100%;
+    max-height: 90vh;
+    overflow: hidden;
+    display: flex;
+    flex-direction: column;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+  }
+
+  .modal-content.large {
+    max-width: 900px;
+  }
+
+  .modal-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 1.5rem;
+    border-bottom: 1px solid #e0e0e0;
+  }
+
+  .modal-header h2 {
+    margin: 0;
+    color: #333;
+  }
+
+  .close-btn {
+    background: none;
+    border: none;
+    font-size: 1.5rem;
+    cursor: pointer;
+    color: #888;
+    padding: 0;
+    width: 2rem;
+    height: 2rem;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+  }
+
+  .close-btn:hover {
+    color: #333;
+  }
+
+  .modal-body {
+    padding: 1.5rem;
+    overflow-y: auto;
+    flex: 1;
+  }
+
+  .validation-section {
+    margin-bottom: 2rem;
+  }
+
+  .validation-section h3 {
+    margin: 0 0 1rem 0;
+    color: #333;
+  }
+
+  .validation-block {
+    padding: 1rem;
+    border-radius: 4px;
+    margin-bottom: 1rem;
+  }
+
+  .validation-block h4 {
+    margin: 0 0 0.75rem 0;
+    font-size: 1rem;
+  }
+
+  .validation-block.errors {
+    background-color: #fee;
+    border-left: 4px solid #dc3545;
+  }
+
+  .validation-block.warnings {
+    background-color: #fff3cd;
+    border-left: 4px solid #ffc107;
+  }
+
+  .validation-block.info {
+    background-color: #e3f2fd;
+    border-left: 4px solid #2196f3;
+  }
+
+  .validation-block.success {
+    background-color: #d4edda;
+    border-left: 4px solid #28a745;
+  }
+
+  .validation-block ul {
+    margin: 0;
+    padding-left: 1.5rem;
+  }
+
+  .validation-block li {
+    margin-bottom: 0.5rem;
+  }
+
+  .severity-error {
+    color: #dc3545;
+  }
+
+  .severity-warning {
+    color: #856404;
+  }
+
+  .severity-info {
+    color: #0d47a1;
+  }
+
+  .test-config {
+    border-top: 1px solid #e0e0e0;
+    padding-top: 1.5rem;
+  }
+
+  .test-config h3 {
+    margin: 0 0 0.5rem 0;
+    color: #333;
+  }
+
+  .help-text {
+    color: #666;
+    font-size: 0.9rem;
+    margin-bottom: 1rem;
+  }
+
+  .user-selector {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+    margin-bottom: 1rem;
+  }
+
+  .user-selector label {
+    font-weight: 500;
+  }
+
+  .user-selector select {
+    flex: 1;
+    padding: 0.5rem;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+  }
+
+  .test-results {
+    margin-top: 1.5rem;
+    padding: 1rem;
+    border-radius: 4px;
+  }
+
+  .test-results.error {
+    background-color: #fee;
+    border-left: 4px solid #dc3545;
+  }
+
+  .test-results.success {
+    background-color: #f9f9f9;
+    border: 1px solid #ddd;
+  }
+
+  .test-results h4 {
+    margin: 0 0 1rem 0;
+  }
+
+  .result-summary {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
+    gap: 1rem;
+    margin-bottom: 1rem;
+  }
+
+  .result-item {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    padding: 0.75rem;
+    background: white;
+    border-radius: 4px;
+  }
+
+  .result-item .label {
+    font-size: 0.8rem;
+    color: #666;
+    margin-bottom: 0.25rem;
+  }
+
+  .result-item .value {
+    font-size: 1.25rem;
+    font-weight: bold;
+    color: #333;
+  }
+
+  .result-item .value.confirmed {
+    color: #28a745;
+  }
+
+  .result-item .value.progress {
+    color: #667eea;
+  }
+
+  .result-warnings {
+    background-color: #fff3cd;
+    padding: 0.75rem;
+    border-radius: 4px;
+    margin-bottom: 1rem;
+  }
+
+  .result-warnings h5 {
+    margin: 0 0 0.5rem 0;
+    color: #856404;
+  }
+
+  .result-warnings ul {
+    margin: 0;
+    padding-left: 1.5rem;
+  }
+
+  .sample-entities {
+    background-color: #e3f2fd;
+    padding: 0.75rem;
+    border-radius: 4px;
+  }
+
+  .sample-entities h5 {
+    margin: 0 0 0.5rem 0;
+    color: #0d47a1;
+  }
+
+  .entities-list {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+  }
+
+  .entity-tag {
+    background-color: white;
+    padding: 0.25rem 0.75rem;
+    border-radius: 12px;
+    font-size: 0.85rem;
+    color: #0d47a1;
+  }
+
+  .no-matches {
+    background-color: #fff3cd;
+    padding: 0.75rem;
+    border-radius: 4px;
+    text-align: center;
+    color: #856404;
+  }
+
+  .modal-footer {
+    padding: 1rem 1.5rem;
+    border-top: 1px solid #e0e0e0;
+    display: flex;
+    justify-content: flex-end;
+  }
+
+  .btn {
+    padding: 0.6rem 1.2rem;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    font-weight: 500;
+    transition: all 0.2s;
+  }
+
+  .btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+
+  .btn-primary {
+    background-color: #667eea;
+    color: white;
+  }
+
+  .btn-primary:hover:not(:disabled) {
+    background-color: #5568d3;
+  }
+
+  .btn-secondary {
+    background-color: #6c757d;
+    color: white;
+  }
+
+  .btn-secondary:hover {
+    background-color: #5a6268;
+  }
+
+  @media (max-width: 600px) {
+    .modal-content {
+      height: 100vh;
+      max-height: 100vh;
+      border-radius: 0;
+    }
+
+    .user-selector {
+      flex-direction: column;
+      align-items: stretch;
+    }
+
+    .result-summary {
+      grid-template-columns: 1fr 1fr;
+    }
+  }
+</style>
diff --git a/src/frontend/src/routes/admin/awards/create/+page.svelte b/src/frontend/src/routes/admin/awards/create/+page.svelte
new file mode 100644
index 0000000..1ba3d11
--- /dev/null
+++ b/src/frontend/src/routes/admin/awards/create/+page.svelte
@@ -0,0 +1,1187 @@
+<script>
+  import { onMount } from 'svelte';
+  import { browser } from '$app/environment';
+  import { awardsAdminAPI } from '$lib/api.js';
+  import FilterBuilder from '../components/FilterBuilder.svelte';
+  import TestAwardModal from '../components/TestAwardModal.svelte';
+
+  let loading = false;
+  let saving = false;
+  let error = null;
+  let isEdit = false;
+  let awardId = null;
+
+  // UI state
+  let showTestModal = false;
+  let activeTab = 'basic'; // basic, modeGroups, rules
+
+  // Form data
+  let formData = {
+    id: '',
+    name: '',
+    description: '',
+    caption: '',
+    category: '',
+    modeGroups: {},
+    rules: {
+      type: 'entity',
+    }
+  };
+
+  // Available bands and modes
+  const ALL_BANDS = ['160m', '80m', '60m', '40m', '30m', '20m', '17m', '15m', '12m', '10m', '6m', '2m', '70cm', '23cm', '13cm', '9cm', '6cm', '3cm'];
+  const ALL_MODES = ['CW', 'SSB', 'AM', 'FM', 'RTTY', 'PSK31', 'FT8', 'FT4', 'JT65', 'JT9', 'MFSK', 'Q65', 'JS8', 'FSK441', 'ISCAT', 'JT6M', 'MSK144'];
+
+  // Validation errors and warnings
+  let validationErrors = [];
+  let validationWarnings = [];
+
+  // Mode groups editor state
+  let newModeGroupName = '';
+  let newModeGroupModes = [];
+
+  onMount(() => {
+    // Check if we're editing an existing award
+    const pathParts = window.location.pathname.split('/');
+    if (pathParts.includes('[id]') || pathParts.length > 5) {
+      // Extract award ID from path
+      const idPart = pathParts[pathParts.length - 1] || pathParts[pathParts.length - 2];
+      if (idPart && idPart !== 'create') {
+        loadAward(idPart);
+      }
+    }
+  });
+
+  async function loadAward(id) {
+    loading = true;
+    try {
+      const data = await awardsAdminAPI.getById(id);
+      formData = {
+        id: data.award.id || '',
+        name: data.award.name || '',
+        description: data.award.description || '',
+        caption: data.award.caption || '',
+        category: data.award.category || '',
+        modeGroups: data.award.modeGroups || {},
+        rules: data.award.rules || { type: 'entity' },
+      };
+      awardId = id;
+      isEdit = true;
+    } catch (err) {
+      error = 'Failed to load award: ' + err.message;
+    } finally {
+      loading = false;
+    }
+  }
+
+  // Safety validation - checks for senseless logic and redundancies
+  function performSafetyValidation() {
+    const errors = [];
+    const warnings = [];
+
+    // Basic field validation
+    if (!formData.id.trim()) errors.push('ID is required');
+    if (!formData.name.trim()) errors.push('Name is required');
+    if (!formData.description.trim()) errors.push('Description is required');
+    if (!formData.caption.trim()) errors.push('Caption is required');
+    if (!formData.category.trim()) errors.push('Category is required');
+
+    // ID format validation
+    if (formData.id && !/^[a-z0-9-]+$/.test(formData.id)) {
+      errors.push('ID must contain only lowercase letters, numbers, and hyphens');
+    }
+
+    // Rules validation
+    if (!formData.rules.type) {
+      errors.push('Rule type is required');
+    }
+
+    // Rule-specific validation
+    switch (formData.rules.type) {
+      case 'entity':
+        validateEntityRule(errors, warnings);
+        break;
+      case 'dok':
+        validateDOKRule(errors, warnings);
+        break;
+      case 'points':
+        validatePointsRule(errors, warnings);
+        break;
+      case 'filtered':
+        validateFilteredRule(errors, warnings);
+        break;
+      case 'counter':
+        validateCounterRule(errors, warnings);
+        break;
+    }
+
+    // Mode groups validation
+    validateModeGroups(errors, warnings);
+
+    // Cross-field validation
+    performCrossFieldValidation(errors, warnings);
+
+    validationErrors = errors;
+    validationWarnings = warnings;
+
+    return errors.length === 0;
+  }
+
+  function validateEntityRule(errors, warnings) {
+    if (!formData.rules.entityType) {
+      errors.push('Entity rule requires entityType');
+    }
+
+    if (!formData.rules.target || formData.rules.target <= 0) {
+      errors.push('Target must be a positive number');
+    }
+
+    // Check for redundant filters
+    if (formData.rules.allowed_bands && formData.rules.filters) {
+      // Check if filters contain a band restriction that conflicts with allowed_bands
+      const filterBands = extractBandFilters(formData.rules.filters);
+      if (filterBands.length > 0) {
+        const overlap = filterBands.every(b => formData.rules.allowed_bands.includes(b));
+        if (overlap) {
+          warnings.push('Band filters are redundant - all filtered bands are already in allowed_bands');
+        }
+      }
+    }
+
+    // Check if satellite_only makes sense with allowed_bands
+    if (formData.rules.satellite_only && formData.rules.allowed_bands) {
+      const satBands = ['2m', '70cm', '23cm', '13cm', '9cm', '6cm', '3cm'];
+      const hasSatBands = formData.rules.allowed_bands.some(b => satBands.includes(b));
+      if (!hasSatBands) {
+        warnings.push('satellite_only is set but no satellite-capable bands (2m, 70cm, etc.) are in allowed_bands');
+      }
+    }
+  }
+
+  function validateDOKRule(errors, warnings) {
+    if (!formData.rules.target || formData.rules.target <= 0) {
+      errors.push('Target must be a positive number');
+    }
+
+    if (formData.rules.confirmationType && formData.rules.confirmationType !== 'dcl') {
+      warnings.push('DOK awards typically use "dcl" as confirmationType');
+    }
+  }
+
+  function validatePointsRule(errors, warnings) {
+    if (!formData.rules.target || formData.rules.target <= 0) {
+      errors.push('Target must be a positive number');
+    }
+
+    if (!formData.rules.stations || formData.rules.stations.length === 0) {
+      errors.push('Points rule requires at least one station');
+    }
+
+    // Check for duplicate callsigns
+    if (formData.rules.stations) {
+      const callsigns = formData.rules.stations.map(s => s.callsign?.toUpperCase());
+      const duplicates = callsigns.filter((c, i) => callsigns.indexOf(c) !== i);
+      if (duplicates.length > 0) {
+        errors.push(`Duplicate station callsigns: ${[...new Set(duplicates)].join(', ')}`);
+      }
+
+      // Check for zero or negative points
+      formData.rules.stations.forEach((station, i) => {
+        if (!station.callsign || !station.callsign.trim()) {
+          errors.push(`Station ${i + 1} is missing callsign`);
+        }
+        if (typeof station.points !== 'number' || station.points <= 0) {
+          errors.push(`Station ${station.callsign || i + 1} must have positive points value`);
+        }
+      });
+    }
+  }
+
+  function validateFilteredRule(errors, warnings) {
+    if (!formData.rules.baseRule) {
+      errors.push('Filtered rule requires baseRule');
+    } else {
+      // Recursively validate base rule
+      const baseRule = formData.rules.baseRule;
+      if (baseRule.type === 'filtered') {
+        errors.push('Nested filtered rules are not supported');
+      }
+    }
+
+    // Check if filters are empty
+    if (!formData.rules.filters || !formData.rules.filters.filters || formData.rules.filters.filters.length === 0) {
+      warnings.push('Filtered rule has no filters - baseRule will be used as-is');
+    }
+  }
+
+  function validateCounterRule(errors, warnings) {
+    if (!formData.rules.target || formData.rules.target <= 0) {
+      errors.push('Target must be a positive number');
+    }
+
+    if (!formData.rules.countBy) {
+      errors.push('Counter rule requires countBy (qso or callsign)');
+    }
+  }
+
+  function validateModeGroups(errors, warnings) {
+    if (!formData.modeGroups) return;
+
+    // Check for empty mode groups
+    for (const [name, modes] of Object.entries(formData.modeGroups)) {
+      if (!Array.isArray(modes) || modes.length === 0) {
+        warnings.push(`Mode group "${name}" is empty`);
+      }
+    }
+
+    // Check for duplicate mode names within a group
+    for (const [name, modes] of Object.entries(formData.modeGroups)) {
+      if (Array.isArray(modes)) {
+        const duplicates = modes.filter((m, i) => modes.indexOf(m) !== i);
+        if (duplicates.length > 0) {
+          warnings.push(`Mode group "${name}" contains duplicates: ${[...new Set(duplicates)].join(', ')}`);
+        }
+      }
+    }
+
+    // Check for redundant mode groups (identical mode sets)
+    const groupKeys = Object.keys(formData.modeGroups);
+    for (let i = 0; i < groupKeys.length; i++) {
+      for (let j = i + 1; j < groupKeys.length; j++) {
+        const modes1 = JSON.stringify(formData.modeGroups[groupKeys[i]]?.sort());
+        const modes2 = JSON.stringify(formData.modeGroups[groupKeys[j]]?.sort());
+        if (modes1 === modes2 && modes1 !== undefined) {
+          warnings.push(`Mode groups "${groupKeys[i]}" and "${groupKeys[j]}" have identical mode sets`);
+        }
+      }
+    }
+
+    // Check if modes are in the known modes list
+    for (const [name, modes] of Object.entries(formData.modeGroups)) {
+      if (Array.isArray(modes)) {
+        const unknownModes = modes.filter(m => !ALL_MODES.includes(m));
+        if (unknownModes.length > 0) {
+          warnings.push(`Mode group "${name}" contains unknown modes: ${unknownModes.join(', ')}`);
+        }
+      }
+    }
+  }
+
+  function performCrossFieldValidation(errors, warnings) {
+    // Check if filters contradict satellite_only
+    if (formData.rules.satellite_only && formData.rules.filters) {
+      const satFilter = findFilterByField(formData.rules.filters, 'satellite');
+      if (satFilter && satFilter.operator === 'eq' && satFilter.value === false) {
+        errors.push('Conflict: satellite_only is true but filter sets satellite=false');
+      }
+    }
+
+    // Check if filters contradict allowed_bands
+    if (formData.rules.allowed_bands && formData.rules.filters) {
+      const bandFilters = extractAllBandFilters(formData.rules.filters);
+      for (const bandFilter of bandFilters) {
+        if (bandFilter.operator === 'nin' && Array.isArray(bandFilter.value)) {
+          // Check if nin filter excludes all allowed_bands
+          const allExcluded = formData.rules.allowed_bands.every(b => bandFilter.value.includes(b));
+          if (allExcluded) {
+            errors.push('Filter excludes all bands in allowed_bands - no QSOs will match');
+          }
+        }
+      }
+    }
+
+    // Check for contradictory filter combinations (e.g., mode=CW AND mode=SSB)
+    if (formData.rules.filters && formData.rules.filters.operator === 'AND') {
+      const fieldFilters = groupFiltersByField(formData.rules.filters);
+      for (const [field, filters] of Object.entries(fieldFilters)) {
+        if (filters.length > 1) {
+          const eqFilters = filters.filter(f => f.operator === 'eq');
+          if (eqFilters.length > 1) {
+            const values = eqFilters.map(f => f.value);
+            if (new Set(values).size > 1) {
+              errors.push(`Impossible filter: ${field} cannot equal multiple values (${values.join(', ')}) with AND operator`);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Helper functions for filter analysis
+  function extractBandFilters(filters, depth = 0) {
+    if (!filters || depth > 5) return [];
+    const result = [];
+
+    if (filters.field === 'band') {
+      result.push(filters);
+    }
+
+    if (filters.filters) {
+      for (const f of filters.filters) {
+        result.push(...extractBandFilters(f, depth + 1));
+      }
+    }
+
+    return result;
+  }
+
+  function extractAllBandFilters(filters) {
+    return extractBandFilters(filters);
+  }
+
+  function findFilterByField(filters, field, depth = 0) {
+    if (!filters || depth > 5) return null;
+
+    if (filters.field === field) return filters;
+
+    if (filters.filters) {
+      for (const f of filters.filters) {
+        const found = findFilterByField(f, field, depth + 1);
+        if (found) return found;
+      }
+    }
+
+    return null;
+  }
+
+  function groupFiltersByField(filters, depth = 0) {
+    if (!filters || depth > 5) return {};
+
+    const result = {};
+
+    if (filters.field) {
+      if (!result[filters.field]) result[filters.field] = [];
+      result[filters.field].push(filters);
+    }
+
+    if (filters.filters) {
+      for (const f of filters.filters) {
+        const nested = groupFiltersByField(f, depth + 1);
+        for (const [field, fList] of Object.entries(nested)) {
+          if (!result[field]) result[field] = [];
+          result[field].push(...fList);
+        }
+      }
+    }
+
+    return result;
+  }
+
+  async function handleSave() {
+    if (!performSafetyValidation()) {
+      return;
+    }
+
+    saving = true;
+    error = null;
+
+    try {
+      if (isEdit) {
+        await awardsAdminAPI.update(awardId, formData);
+      } else {
+        await awardsAdminAPI.create(formData);
+      }
+      window.location.href = '/admin/awards';
+    } catch (err) {
+      error = err.message;
+    } finally {
+      saving = false;
+    }
+  }
+
+  function handleRulesChange(newRules) {
+    formData = { ...formData, rules: newRules };
+    performSafetyValidation();
+  }
+
+  function handleFiltersChange(newFilters) {
+    formData = { ...formData, rules: { ...formData.rules, filters: newFilters } };
+    performSafetyValidation();
+  }
+
+  // Mode groups management
+  function addModeGroup() {
+    if (!newModeGroupName.trim()) return;
+    if (!newModeGroupModes.length) {
+      alert('Please add at least one mode to the group');
+      return;
+    }
+
+    if (formData.modeGroups[newModeGroupName]) {
+      alert('A mode group with this name already exists');
+      return;
+    }
+
+    formData = {
+      ...formData,
+      modeGroups: {
+        ...formData.modeGroups,
+        [newModeGroupName]: [...newModeGroupModes],
+      }
+    };
+
+    newModeGroupName = '';
+    newModeGroupModes = [];
+    performSafetyValidation();
+  }
+
+  function removeModeGroup(name) {
+    const { [name]: removed, ...rest } = formData.modeGroups;
+    formData = { ...formData, modeGroups: rest };
+    performSafetyValidation();
+  }
+
+  function testAward() {
+    showTestModal = true;
+  }
+
+  function generateIdFromName() {
+    if (!isEdit && formData.name && !formData.id) {
+      const id = formData.name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '')
+        .substring(0, 30);
+      formData = { ...formData, id };
+    }
+  }
+</script>
+
+{#if loading}
+  <div class="loading">Loading award definition...</div>
+{:else}
+  <div class="award-editor">
+    <div class="header">
+      <h1>{isEdit ? 'Edit Award' : 'Create New Award'}</h1>
+      <div class="header-actions">
+        <button class="btn btn-secondary" on:click={testAward}>Test Award</button>
+        <button class="btn btn-primary" on:click={handleSave} disabled={saving}>
+          {saving ? 'Saving...' : isEdit ? 'Update Award' : 'Create Award'}
+        </button>
+      </div>
+    </div>
+
+    {#if error}
+      <div class="error">{error}</div>
+    {/if}
+
+    {#if validationErrors.length > 0}
+      <div class="validation-errors">
+        <h3>Please fix the following errors:</h3>
+        <ul>
+          {#each validationErrors as err}
+            <li>{err}</li>
+          {/each}
+        </ul>
+      </div>
+    {/if}
+
+    {#if validationWarnings.length > 0}
+      <div class="validation-warnings">
+        <h3>Warnings:</h3>
+        <ul>
+          {#each validationWarnings as warn}
+            <li>{warn}</li>
+          {/each}
+        </ul>
+      </div>
+    {/if}
+
+    <div class="tabs">
+      <button
+        class="tab {activeTab === 'basic' ? 'active' : ''}"
+        on:click={() => activeTab = 'basic'}
+      >
+        Basic Info
+      </button>
+      <button
+        class="tab {activeTab === 'modeGroups' ? 'active' : ''}"
+        on:click={() => activeTab = 'modeGroups'}
+      >
+        Mode Groups
+      </button>
+      <button
+        class="tab {activeTab === 'rules' ? 'active' : ''}"
+        on:click={() => activeTab = 'rules'}
+      >
+        Rules
+      </button>
+    </div>
+
+    <div class="tab-content">
+      {#if activeTab === 'basic'}
+        <div class="form-section">
+          <div class="form-group">
+            <label for="award-id">Award ID *</label>
+            <input
+              id="award-id"
+              type="text"
+              bind:value={formData.id}
+              disabled={isEdit}
+              on:blur={generateIdFromName}
+              placeholder="e.g., dxcc, was, dld"
+              required
+            />
+            <small>Unique identifier for the award (lowercase letters, numbers, hyphens only)</small>
+          </div>
+
+          <div class="form-group">
+            <label for="award-name">Award Name *</label>
+            <input
+              id="award-name"
+              type="text"
+              bind:value={formData.name}
+              on:blur={generateIdFromName}
+              placeholder="e.g., DXCC, Worked All States"
+              required
+            />
+          </div>
+
+          <div class="form-group">
+            <label for="award-description">Short Description *</label>
+            <input
+              id="award-description"
+              type="text"
+              bind:value={formData.description}
+              placeholder="Brief description (1 line)"
+              required
+            />
+          </div>
+
+          <div class="form-group">
+            <label for="award-caption">Detailed Caption *</label>
+            <textarea
+              id="award-caption"
+              bind:value={formData.caption}
+              placeholder="Full explanation of the award requirements"
+              rows="4"
+              required
+            ></textarea>
+          </div>
+
+          <div class="form-group">
+            <label for="award-category">Category *</label>
+            <input
+              id="award-category"
+              type="text"
+              bind:value={formData.category}
+              placeholder="e.g., dxcc, darc, vucc"
+              required
+            />
+            <small>Category for grouping awards (e.g., dxcc, darc, vucc, was, special)</small>
+          </div>
+        </div>
+      {/if}
+
+      {#if activeTab === 'modeGroups'}
+        <div class="form-section">
+          <h2>Mode Groups</h2>
+          <p class="help-text">Define mode groups for filtering in the award detail view. This is optional.</p>
+
+          {#if Object.keys(formData.modeGroups || {}).length > 0}
+            <div class="mode-groups-list">
+              {#each Object.entries(formData.modeGroups || {}) as [name, modes]}
+                <div class="mode-group-item">
+                  <div class="mode-group-header">
+                    <strong>{name}</strong>
+                    <button class="btn-remove" on:click={() => removeModeGroup(name)}>Remove</button>
+                  </div>
+                  <div class="mode-group-modes">
+                    {modes.join(', ')}
+                  </div>
+                </div>
+              {/each}
+            </div>
+          {:else}
+            <p class="empty-state">No mode groups defined yet.</p>
+          {/if}
+
+          <div class="add-mode-group">
+            <h3>Add Mode Group</h3>
+            <div class="form-group">
+              <label>Group Name</label>
+              <input type="text" bind:value={newModeGroupName} placeholder="e.g., Digi-Modes" />
+            </div>
+            <div class="form-group">
+              <label>Modes</label>
+              <div class="mode-selector">
+                {#each ALL_MODES as mode}
+                  <label class="mode-checkbox">
+                    <input
+                      type="checkbox"
+                      bind:group={newModeGroupModes}
+                      value={mode}
+                    />
+                    {mode}
+                  </label>
+                {/each}
+              </div>
+            </div>
+            <button class="btn btn-secondary" on:click={addModeGroup}>Add Mode Group</button>
+          </div>
+        </div>
+      {/if}
+
+      {#if activeTab === 'rules'}
+        <div class="form-section">
+          <h2>Award Rules</h2>
+
+          <div class="form-group">
+            <label for="rule-type">Rule Type *</label>
+            <select id="rule-type" bind:value={formData.rules.type}>
+              <option value="entity">Entity (count unique entities)</option>
+              <option value="dok">DOK (count unique DOK/band/mode)</option>
+              <option value="points">Points (sum points from stations)</option>
+              <option value="filtered">Filtered (base rule with filters)</option>
+              <option value="counter">Counter (count QSOs or callsigns)</option>
+            </select>
+          </div>
+
+          {#if formData.rules.type === 'entity'}
+            <div class="rule-config">
+              <h3>Entity Rule Configuration</h3>
+
+              <div class="form-group">
+                <label>Entity Type *</label>
+                <select bind:value={formData.rules.entityType}>
+                  <option value="">Select entity type</option>
+                  <option value="dxcc">DXCC Entity</option>
+                  <option value="state">State</option>
+                  <option value="grid">Grid Square (first 4 chars)</option>
+                  <option value="callsign">Callsign</option>
+                </select>
+              </div>
+
+              <div class="form-group">
+                <label>Target *</label>
+                <input type="number" min="1" bind:value={formData.rules.target} />
+              </div>
+
+              <div class="form-group">
+                <label>Display Field (optional)</label>
+                <input
+                  type="text"
+                  bind:value={formData.rules.displayField}
+                  placeholder="e.g., entity, state, grid"
+                />
+                <small>Field to display as entity name (defaults to entity value)</small>
+              </div>
+
+              <div class="form-group">
+                <label>
+                  <input type="checkbox" bind:checked={formData.rules.satellite_only} />
+                  Satellite Only (only count QSOs with satName)
+                </label>
+              </div>
+
+              <div class="form-group">
+                <label>Allowed Bands (optional)</label>
+                <div class="bands-selector">
+                  {#each ALL_BANDS as band}
+                    <label class="band-checkbox">
+                      <input
+                        type="checkbox"
+                        bind:group={formData.rules.allowed_bands}
+                        value={band}
+                      />
+                      {band}
+                    </label>
+                  {/each}
+                </div>
+                <small>Leave empty to allow all bands</small>
+              </div>
+            </div>
+          {:else if formData.rules.type === 'dok'}
+            <div class="rule-config">
+              <h3>DOK Rule Configuration</h3>
+
+              <div class="form-group">
+                <label>Target *</label>
+                <input type="number" min="1" bind:value={formData.rules.target} />
+              </div>
+
+              <div class="form-group">
+                <label>Display Field (optional)</label>
+                <input
+                  type="text"
+                  bind:value={formData.rules.displayField}
+                  placeholder="e.g., darcDok"
+                />
+              </div>
+
+              <div class="info-box">
+                DOK rules count unique (DOK, band, mode) combinations with DCL confirmation.
+              </div>
+            </div>
+          {:else if formData.rules.type === 'points'}
+            <div class="rule-config">
+              <h3>Points Rule Configuration</h3>
+
+              <div class="form-group">
+                <label>Target (points required) *</label>
+                <input type="number" min="1" bind:value={formData.rules.target} />
+              </div>
+
+              <div class="form-group">
+                <label>Count Mode *</label>
+                <select bind:value={formData.rules.countMode}>
+                  <option value="perStation">Per Station (each station once)</option>
+                  <option value="perBandMode">Per Band/Mode (per station per band/mode)</option>
+                  <option value="perQso">Per QSO (each confirmed QSO)</option>
+                </select>
+              </div>
+
+              <div class="form-group">
+                <label>Stations *</label>
+                <div class="stations-editor">
+                  {#if formData.rules.stations && formData.rules.stations.length > 0}
+                    {#each formData.rules.stations as station, i}
+                      <div class="station-row">
+                        <input
+                          type="text"
+                          bind:value={station.callsign}
+                          placeholder="Callsign"
+                        />
+                        <input
+                          type="number"
+                          min="1"
+                          bind:value={station.points}
+                          placeholder="Points"
+                        />
+                        <button
+                          class="btn-remove"
+                          on:click={() => formData.rules.stations.splice(i, 1)}
+                        >
+                          Remove
+                        </button>
+                      </div>
+                    {/each}
+                  {:else}
+                    <p class="empty-state">No stations defined.</p>
+                  {/if}
+                  <button
+                    class="btn btn-secondary"
+                    on:click={() => {
+                      if (!formData.rules.stations) formData.rules.stations = [];
+                      formData.rules.stations.push({ callsign: '', points: 1 });
+                    }}
+                  >
+                    Add Station
+                  </button>
+                </div>
+              </div>
+            </div>
+          {:else if formData.rules.type === 'filtered'}
+            <div class="rule-config">
+              <h3>Filtered Rule Configuration</h3>
+
+              <div class="info-box">
+                Filtered rules use a base rule with additional filter conditions.
+              </div>
+
+              <div class="form-group">
+                <label>Base Rule Type *</label>
+                <select
+                  value={formData.rules.baseRule?.type || 'entity'}
+                  on:change={(e) => {
+                    formData.rules.baseRule = { type: e.target.value };
+                  }}
+                >
+                  <option value="entity">Entity</option>
+                </select>
+              </div>
+
+              {#if formData.rules.baseRule?.type === 'entity'}
+                <div class="base-rule-config">
+                  <div class="form-group">
+                    <label>Entity Type *</label>
+                    <select bind:value={formData.rules.baseRule.entityType}>
+                      <option value="dxcc">DXCC Entity</option>
+                      <option value="state">State</option>
+                      <option value="grid">Grid Square</option>
+                      <option value="callsign">Callsign</option>
+                    </select>
+                  </div>
+
+                  <div class="form-group">
+                    <label>Target *</label>
+                    <input type="number" min="1" bind:value={formData.rules.baseRule.target} />
+                  </div>
+                </div>
+              {/if}
+            </div>
+          {:else if formData.rules.type === 'counter'}
+            <div class="rule-config">
+              <h3>Counter Rule Configuration</h3>
+
+              <div class="form-group">
+                <label>Target *</label>
+                <input type="number" min="1" bind:value={formData.rules.target} />
+              </div>
+
+              <div class="form-group">
+                <label>Count By *</label>
+                <select bind:value={formData.rules.countBy}>
+                  <option value="qso">Count QSOs</option>
+                  <option value="callsign">Count unique callsigns</option>
+                </select>
+              </div>
+
+              <div class="form-group">
+                <label>Display Field (optional)</label>
+                <input
+                  type="text"
+                  bind:value={formData.rules.displayField}
+                  placeholder="e.g., callsign"
+                />
+              </div>
+            </div>
+          {/if}
+
+          <!-- Filters section (common to all rule types) -->
+          <div class="filters-section">
+            <h3>Filters</h3>
+            <p class="help-text">Add optional filters to restrict which QSOs count toward this award.</p>
+            <FilterBuilder
+              bind:filters={formData.rules.filters}
+              onChange={handleFiltersChange}
+            />
+          </div>
+        </div>
+      {/if}
+    </div>
+  </div>
+
+  {#if showTestModal && (formData.id || awardId)}
+    <TestAwardModal
+      awardId={awardId || formData.id}
+      awardDefinition={formData}
+      onClose={() => showTestModal = false}
+    />
+  {/if}
+{/if}
+
+<style>
+  .award-editor {
+    padding: 2rem;
+    max-width: 1200px;
+    margin: 0 auto;
+  }
+
+  .loading {
+    text-align: center;
+    padding: 3rem;
+    font-size: 1.2rem;
+    color: #666;
+  }
+
+  .header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1.5rem;
+    flex-wrap: wrap;
+    gap: 1rem;
+  }
+
+  .header h1 {
+    margin: 0;
+    color: #333;
+  }
+
+  .header-actions {
+    display: flex;
+    gap: 1rem;
+  }
+
+  .error, .validation-errors {
+    background-color: #fee;
+    border: 1px solid #fcc;
+    padding: 1rem;
+    border-radius: 4px;
+    color: #c00;
+    margin-bottom: 1rem;
+  }
+
+  .validation-warnings {
+    background-color: #fff3cd;
+    border: 1px solid #ffc107;
+    padding: 1rem;
+    border-radius: 4px;
+    color: #856404;
+    margin-bottom: 1rem;
+  }
+
+  .validation-errors h3, .validation-warnings h3 {
+    margin: 0 0 0.5rem 0;
+    font-size: 1rem;
+  }
+
+  .validation-errors ul, .validation-warnings ul {
+    margin: 0;
+    padding-left: 1.5rem;
+  }
+
+  .tabs {
+    display: flex;
+    gap: 0.5rem;
+    margin-bottom: 1.5rem;
+    border-bottom: 2px solid #ddd;
+  }
+
+  .tab {
+    padding: 0.75rem 1.5rem;
+    background: none;
+    border: none;
+    cursor: pointer;
+    font-size: 1rem;
+    font-weight: 500;
+    color: #666;
+    position: relative;
+    top: 2px;
+  }
+
+  .tab:hover {
+    color: #333;
+  }
+
+  .tab.active {
+    color: #667eea;
+    border-bottom: 2px solid #667eea;
+  }
+
+  .form-section {
+    background: white;
+    padding: 2rem;
+    border-radius: 8px;
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+  }
+
+  .form-group {
+    margin-bottom: 1.5rem;
+  }
+
+  .form-group label {
+    display: block;
+    font-weight: 500;
+    margin-bottom: 0.5rem;
+    color: #333;
+  }
+
+  .form-group input[type="text"],
+  .form-group input[type="number"],
+  .form-group select,
+  .form-group textarea {
+    width: 100%;
+    padding: 0.6rem;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    font-size: 1rem;
+  }
+
+  .form-group textarea {
+    font-family: inherit;
+    resize: vertical;
+  }
+
+  .form-group small {
+    display: block;
+    margin-top: 0.25rem;
+    color: #888;
+    font-size: 0.85rem;
+  }
+
+  .btn {
+    padding: 0.6rem 1.2rem;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    font-weight: 500;
+    transition: all 0.2s;
+  }
+
+  .btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+
+  .btn-primary {
+    background-color: #667eea;
+    color: white;
+  }
+
+  .btn-primary:hover:not(:disabled) {
+    background-color: #5568d3;
+  }
+
+  .btn-secondary {
+    background-color: #6c757d;
+    color: white;
+  }
+
+  .btn-secondary:hover {
+    background-color: #5a6268;
+  }
+
+  .btn-remove {
+    background-color: #e74c3c;
+    color: white;
+    padding: 0.4rem 0.8rem;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 0.85rem;
+  }
+
+  .btn-remove:hover {
+    background-color: #c0392b;
+  }
+
+  .help-text {
+    color: #666;
+    font-style: italic;
+    margin-bottom: 1rem;
+  }
+
+  .mode-groups-list {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+    margin-bottom: 2rem;
+  }
+
+  .mode-group-item {
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 1rem;
+    background: #f9f9f9;
+  }
+
+  .mode-group-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 0.5rem;
+  }
+
+  .mode-group-modes {
+    color: #666;
+    font-size: 0.9rem;
+  }
+
+  .add-mode-group {
+    border-top: 1px solid #ddd;
+    padding-top: 2rem;
+  }
+
+  .add-mode-group h3 {
+    margin-bottom: 1rem;
+  }
+
+  .mode-selector, .bands-selector {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(100px, 1fr));
+    gap: 0.5rem;
+    margin-top: 0.5rem;
+  }
+
+  .mode-checkbox, .band-checkbox {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.25rem;
+    cursor: pointer;
+  }
+
+  .mode-checkbox input, .band-checkbox input {
+    cursor: pointer;
+  }
+
+  .rule-config {
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 1.5rem;
+    margin-bottom: 1.5rem;
+    background: #f9f9f9;
+  }
+
+  .rule-config h3 {
+    margin-top: 0;
+    margin-bottom: 1rem;
+  }
+
+  .info-box {
+    background-color: #e3f2fd;
+    border-left: 4px solid #2196f3;
+    padding: 1rem;
+    margin-top: 1rem;
+    color: #0d47a1;
+  }
+
+  .stations-editor {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+
+  .station-row {
+    display: flex;
+    gap: 0.5rem;
+    align-items: center;
+  }
+
+  .station-row input:first-child {
+    flex: 2;
+  }
+
+  .station-row input:last-child {
+    flex: 1;
+    width: 100px;
+  }
+
+  .base-rule-config {
+    padding-left: 1rem;
+    border-left: 3px solid #ddd;
+  }
+
+  .filters-section {
+    margin-top: 2rem;
+    padding-top: 2rem;
+    border-top: 1px solid #ddd;
+  }
+
+  .empty-state {
+    color: #888;
+    font-style: italic;
+    text-align: center;
+    padding: 1rem;
+  }
+
+  @media (max-width: 768px) {
+    .award-editor {
+      padding: 1rem;
+    }
+
+    .header {
+      flex-direction: column;
+      align-items: stretch;
+    }
+
+    .header-actions {
+      flex-direction: column;
+    }
+
+    .mode-selector, .bands-selector {
+      grid-template-columns: repeat(auto-fill, minmax(80px, 1fr));
+    }
+
+    .station-row {
+      flex-direction: column;
+      align-items: stretch;
+    }
+
+    .station-row input {
+      width: 100%;
+    }
+  }
+</style>