MongoDB Atlas App Services and Serverless Functions: SQL-Style Database Integration Patterns

Modern applications increasingly rely on serverless architectures for scalability, cost-effectiveness, and rapid development cycles. MongoDB Atlas App Services provides a comprehensive serverless platform that combines database operations, authentication, and business logic into a unified development experience.

Understanding how to leverage Atlas App Services with SQL-familiar patterns enables you to build robust, scalable applications while maintaining the development productivity and query patterns your team already knows.

The Serverless Database Challenge

Traditional application architectures require managing separate services for databases, authentication, APIs, and business logic:

// Traditional multi-service architecture complexity
const express = require('express');
const mongoose = require('mongoose');
const jwt = require('jsonwebtoken');
const bcrypt = require('bcrypt');

// Database connection
mongoose.connect('mongodb://localhost:27017/myapp');

// Authentication middleware
const authenticateToken = (req, res, next) => {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];

  if (!token) {
    return res.sendStatus(401);
  }

  jwt.verify(token, process.env.ACCESS_TOKEN_SECRET, (err, user) => {
    if (err) return res.sendStatus(403);
    req.user = user;
    next();
  });
};

// API endpoint with manual validation
app.post('/api/orders', authenticateToken, async (req, res) => {
  try {
    // Manual validation
    if (!req.body.items || req.body.items.length === 0) {
      return res.status(400).json({ error: 'Items required' });
    }

    // Business logic
    const total = req.body.items.reduce((sum, item) => sum + item.price * item.quantity, 0);

    // Database operation
    const order = new Order({
      user_id: req.user.id,
      items: req.body.items,
      total: total,
      status: 'pending'
    });

    await order.save();
    res.json(order);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

This approach requires managing infrastructure, scaling concerns, security implementations, and coordination between multiple services.

MongoDB Atlas App Services Architecture

Atlas App Services simplifies this by providing integrated serverless functions, authentication, and data access in a single platform:

// Atlas App Services Function - Serverless and integrated
exports = async function(changeEvent) {
  const { insertedId, fullDocument } = changeEvent;

  // Automatic authentication and context
  const user = context.user;
  const mongodb = context.services.get("mongodb-atlas");
  const db = mongodb.db("ecommerce");

  if (fullDocument.status === 'completed') {
    // Update inventory automatically
    const inventoryUpdates = fullDocument.items.map(item => ({
      updateOne: {
        filter: { product_id: item.product_id },
        update: { $inc: { quantity: -item.quantity } }
      }
    }));

    await db.collection("inventory").bulkWrite(inventoryUpdates);

    // Send notification via integrated services
    await context.functions.execute("sendOrderConfirmation", user.id, fullDocument);
  }
};

SQL-Style Function Development

Atlas App Services functions can be approached using familiar SQL patterns for data access and business logic:

Database Functions

-- Traditional stored procedure pattern
CREATE OR REPLACE FUNCTION create_order(
  user_id UUID,
  items JSONB,
  shipping_address JSONB
) RETURNS JSONB AS $$
DECLARE
  order_total DECIMAL(10,2);
  new_order_id UUID;
BEGIN
  -- Calculate order total
  SELECT SUM((item->>'price')::DECIMAL * (item->>'quantity')::INTEGER)
  INTO order_total
  FROM jsonb_array_elements(items) AS item;

  -- Validate inventory
  IF EXISTS (
    SELECT 1 FROM jsonb_array_elements(items) AS item
    JOIN products p ON p.id = (item->>'product_id')::UUID
    WHERE p.quantity < (item->>'quantity')::INTEGER
  ) THEN
    RAISE EXCEPTION 'Insufficient inventory for one or more items';
  END IF;

  -- Create order
  INSERT INTO orders (user_id, items, total, status, shipping_address)
  VALUES (user_id, items, order_total, 'pending', shipping_address)
  RETURNING id INTO new_order_id;

  RETURN jsonb_build_object(
    'order_id', new_order_id,
    'total', order_total,
    'status', 'created'
  );
END;
$$ LANGUAGE plpgsql;

Atlas App Services equivalent using SQL-familiar logic:

// Atlas Function: createOrder
exports = async function(userId, items, shippingAddress) {
  const mongodb = context.services.get("mongodb-atlas");
  const db = mongodb.db("ecommerce");

  // SQL-style aggregation for total calculation
  const orderTotal = await db.collection("temp").aggregate([
    { $match: { _id: { $exists: false } } }, // Empty pipeline start
    {
      $project: {
        total: {
          $sum: {
            $map: {
              input: items,
              as: "item",
              in: { $multiply: ["$$item.price", "$$item.quantity"] }
            }
          }
        }
      }
    }
  ]).next();

  // SQL-style validation query
  const inventoryCheck = await db.collection("products").aggregate([
    {
      $match: {
        _id: { $in: items.map(item => BSON.ObjectId(item.product_id)) }
      }
    },
    {
      $project: {
        product_id: "$_id",
        available_quantity: "$quantity",
        requested_quantity: {
          $arrayElemAt: [
            {
              $map: {
                input: {
                  $filter: {
                    input: items,
                    cond: { $eq: ["$$this.product_id", { $toString: "$_id" }] }
                  }
                },
                as: "item",
                in: "$$item.quantity"
              }
            },
            0
          ]
        }
      }
    },
    {
      $match: {
        $expr: { $lt: ["$available_quantity", "$requested_quantity"] }
      }
    }
  ]).toArray();

  if (inventoryCheck.length > 0) {
    throw new Error(`Insufficient inventory for products: ${inventoryCheck.map(p => p.product_id).join(', ')}`);
  }

  // SQL-style insert with returning pattern
  const result = await db.collection("orders").insertOne({
    user_id: BSON.ObjectId(userId),
    items: items,
    total: orderTotal.total,
    status: 'pending',
    shipping_address: shippingAddress,
    created_at: new Date()
  });

  return {
    order_id: result.insertedId,
    total: orderTotal.total,
    status: 'created'
  };
};

Authentication and Authorization Functions

// Atlas Function: User Registration with SQL-style validation
exports = async function(email, password, profile) {
  const mongodb = context.services.get("mongodb-atlas");
  const db = mongodb.db("userdata");

  // SQL-style uniqueness check
  const existingUser = await db.collection("users").findOne({ 
    email: { $regex: new RegExp(`^${email}$`, 'i') }
  });

  if (existingUser) {
    throw new Error('User with this email already exists');
  }

  // SQL-style validation patterns
  const emailPattern = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
  if (!emailPattern.test(email)) {
    throw new Error('Invalid email format');
  }

  if (password.length < 8) {
    throw new Error('Password must be at least 8 characters long');
  }

  // Create user with Atlas authentication
  const userResult = await context.services.get("mongodb-atlas").callFunction("registerUser", {
    email: email,
    password: password
  });

  // Create user profile with SQL-style structure
  const userProfile = await db.collection("user_profiles").insertOne({
    user_id: userResult.user_id,
    email: email,
    profile: profile,
    status: 'active',
    created_at: new Date(),
    updated_at: new Date(),
    preferences: {
      notifications: true,
      theme: 'auto',
      language: 'en'
    }
  });

  return {
    user_id: userResult.user_id,
    profile_id: userProfile.insertedId,
    status: 'created'
  };
};

Data Access Patterns with App Services

HTTP Endpoints with SQL-Style Routing

// Atlas HTTPS Endpoint: /api/orders
exports = async function(request, response) {
  const { httpMethod, query, body, headers } = request;

  // SQL-style route handling
  switch (httpMethod) {
    case 'GET':
      return await handleGetOrders(query, headers);
    case 'POST':
      return await handleCreateOrder(body, headers);
    case 'PUT':
      return await handleUpdateOrder(body, headers);
    case 'DELETE':
      return await handleDeleteOrder(query, headers);
    default:
      response.setStatusCode(405);
      return { error: 'Method not allowed' };
  }
};

async function handleGetOrders(query, headers) {
  const mongodb = context.services.get("mongodb-atlas");
  const db = mongodb.db("ecommerce");

  // SQL-style pagination and filtering
  const page = parseInt(query.page || '1');
  const limit = parseInt(query.limit || '20');
  const skip = (page - 1) * limit;

  // Build SQL-style filter conditions
  const filter = {};
  if (query.status) {
    filter.status = { $in: query.status.split(',') };
  }
  if (query.date_from) {
    filter.created_at = { $gte: new Date(query.date_from) };
  }
  if (query.date_to) {
    filter.created_at = { ...filter.created_at, $lte: new Date(query.date_to) };
  }

  // SQL-style aggregation with joins
  const orders = await db.collection("orders").aggregate([
    { $match: filter },
    {
      $lookup: {
        from: "users",
        localField: "user_id",
        foreignField: "_id",
        as: "user_info"
      }
    },
    {
      $unwind: "$user_info"
    },
    {
      $project: {
        order_id: "$_id",
        user_email: "$user_info.email",
        total: 1,
        status: 1,
        created_at: 1,
        item_count: { $size: "$items" }
      }
    },
    { $sort: { created_at: -1 } },
    { $skip: skip },
    { $limit: limit }
  ]).toArray();

  const totalCount = await db.collection("orders").countDocuments(filter);

  return {
    data: orders,
    pagination: {
      page: page,
      limit: limit,
      total: totalCount,
      pages: Math.ceil(totalCount / limit)
    }
  };
}

GraphQL Integration with SQL Patterns

// Atlas GraphQL Custom Resolver
exports = async function(parent, args, context, info) {
  const { input } = args;
  const mongodb = context.services.get("mongodb-atlas");
  const db = mongodb.db("blog");

  // SQL-style full-text search with joins
  const articles = await db.collection("articles").aggregate([
    {
      $match: {
        $and: [
          { $text: { $search: input.searchTerm } },
          { status: "published" },
          input.category ? { category: input.category } : {}
        ]
      }
    },
    {
      $lookup: {
        from: "users",
        localField: "author_id",
        foreignField: "_id",
        as: "author"
      }
    },
    {
      $unwind: "$author"
    },
    {
      $addFields: {
        relevance_score: { $meta: "textScore" },
        engagement_score: {
          $add: [
            { $multiply: ["$view_count", 0.1] },
            { $multiply: ["$like_count", 0.3] },
            { $multiply: ["$comment_count", 0.6] }
          ]
        }
      }
    },
    {
      $project: {
        title: 1,
        excerpt: 1,
        author_name: "$author.name",
        author_avatar: "$author.avatar_url",
        published_date: 1,
        reading_time: 1,
        tags: 1,
        relevance_score: 1,
        engagement_score: 1,
        combined_score: {
          $add: [
            { $multiply: ["$relevance_score", 0.7] },
            { $multiply: ["$engagement_score", 0.3] }
          ]
        }
      }
    },
    { $sort: { combined_score: -1, published_date: -1 } },
    { $limit: input.limit || 20 }
  ]).toArray();

  return {
    articles: articles,
    total: articles.length,
    search_term: input.searchTerm
  };
};

Real-Time Data Synchronization

Database Triggers with SQL-Style Logic

// Atlas Database Trigger: Order Status Changes
exports = async function(changeEvent) {
  const { operationType, fullDocument, updateDescription } = changeEvent;

  if (operationType === 'update' && updateDescription.updatedFields.status) {
    const mongodb = context.services.get("mongodb-atlas");
    const db = mongodb.db("ecommerce");

    const order = fullDocument;
    const newStatus = updateDescription.updatedFields.status;

    // SQL-style cascading updates based on status
    switch (newStatus) {
      case 'confirmed':
        // Update inventory like SQL UPDATE with JOIN
        const inventoryUpdates = order.items.map(item => ({
          updateOne: {
            filter: { product_id: item.product_id },
            update: {
              $inc: { 
                quantity: -item.quantity,
                reserved_quantity: item.quantity
              }
            }
          }
        }));

        await db.collection("inventory").bulkWrite(inventoryUpdates);
        break;

      case 'shipped':
        // SQL-style insert into shipping records
        await db.collection("shipping_records").insertOne({
          order_id: order._id,
          tracking_number: generateTrackingNumber(),
          carrier: order.shipping_method,
          shipped_date: new Date(),
          estimated_delivery: calculateDeliveryDate(order.shipping_address)
        });

        // Update user loyalty points like SQL computed columns
        await db.collection("users").updateOne(
          { _id: order.user_id },
          {
            $inc: { 
              loyalty_points: Math.floor(order.total * 0.1),
              orders_completed: 1
            },
            $set: { last_order_date: new Date() }
          }
        );
        break;

      case 'delivered':
        // Release reserved inventory like SQL constraint updates
        const releaseUpdates = order.items.map(item => ({
          updateOne: {
            filter: { product_id: item.product_id },
            update: {
              $inc: { reserved_quantity: -item.quantity }
            }
          }
        }));

        await db.collection("inventory").bulkWrite(releaseUpdates);

        // Schedule review request like SQL scheduled jobs
        await context.functions.execute("scheduleReviewRequest", order._id, order.user_id);
        break;
    }
  }
};

function generateTrackingNumber() {
  return 'TRK' + Date.now() + Math.random().toString(36).substr(2, 5).toUpperCase();
}

function calculateDeliveryDate(address) {
  // Business logic for delivery estimation
  const baseDelivery = new Date();
  baseDelivery.setDate(baseDelivery.getDate() + 3); // 3 days standard

  // Add extra days for remote areas
  if (address.state && ['AK', 'HI'].includes(address.state)) {
    baseDelivery.setDate(baseDelivery.getDate() + 2);
  }

  return baseDelivery;
}

Scheduled Functions for Maintenance

// Atlas Scheduled Function: Daily Maintenance Tasks
exports = async function() {
  const mongodb = context.services.get("mongodb-atlas");
  const db = mongodb.db("ecommerce");

  // SQL-style cleanup operations
  const yesterday = new Date();
  yesterday.setDate(yesterday.getDate() - 1);

  // Clean up expired sessions like SQL DELETE with JOIN
  await db.collection("user_sessions").deleteMany({
    expires_at: { $lt: new Date() }
  });

  // Archive old orders like SQL INSERT INTO archive SELECT
  const oldOrders = await db.collection("orders").aggregate([
    {
      $match: {
        status: { $in: ['completed', 'cancelled'] },
        updated_at: { $lt: new Date(Date.now() - 90 * 24 * 60 * 60 * 1000) }
      }
    }
  ]).toArray();

  if (oldOrders.length > 0) {
    await db.collection("orders_archive").insertMany(oldOrders);
    const orderIds = oldOrders.map(order => order._id);
    await db.collection("orders").deleteMany({ _id: { $in: orderIds } });
  }

  // Update analytics like SQL materialized views
  await db.collection("daily_analytics").insertOne({
    date: yesterday,
    metrics: await calculateDailyMetrics(db, yesterday),
    generated_at: new Date()
  });

  console.log(`Daily maintenance completed: Cleaned ${oldOrders.length} orders, updated analytics`);
};

async function calculateDailyMetrics(db, date) {
  const startOfDay = new Date(date);
  startOfDay.setHours(0, 0, 0, 0);
  const endOfDay = new Date(date);
  endOfDay.setHours(23, 59, 59, 999);

  // SQL-style aggregation for daily metrics
  const metrics = await db.collection("orders").aggregate([
    {
      $match: {
        created_at: { $gte: startOfDay, $lte: endOfDay }
      }
    },
    {
      $group: {
        _id: null,
        total_orders: { $sum: 1 },
        total_revenue: { $sum: "$total" },
        avg_order_value: { $avg: "$total" },
        unique_customers: { $addToSet: "$user_id" }
      }
    },
    {
      $project: {
        _id: 0,
        total_orders: 1,
        total_revenue: 1,
        avg_order_value: { $round: ["$avg_order_value", 2] },
        unique_customers: { $size: "$unique_customers" }
      }
    }
  ]).next();

  return metrics || {
    total_orders: 0,
    total_revenue: 0,
    avg_order_value: 0,
    unique_customers: 0
  };
}

Security and Authentication Patterns

Rule-Based Access Control

// Atlas App Services Rules: Collection-level security
{
  "roles": [
    {
      "name": "user",
      "apply_when": {
        "%%user.custom_data.role": "customer"
      },
      "read": {
        "user_id": "%%user.id"
      },
      "write": {
        "$and": [
          { "user_id": "%%user.id" },
          { "status": { "$nin": ["completed", "cancelled"] } }
        ]
      }
    },
    {
      "name": "admin",
      "apply_when": {
        "%%user.custom_data.role": "admin"
      },
      "read": true,
      "write": true
    }
  ]
}

SQL-Style Permission Checking

// Atlas Function: Check User Permissions
exports = async function(userId, resource, action) {
  const mongodb = context.services.get("mongodb-atlas");
  const db = mongodb.db("auth");

  // SQL-style permission lookup with joins
  const permissions = await db.collection("user_permissions").aggregate([
    {
      $match: { user_id: BSON.ObjectId(userId) }
    },
    {
      $lookup: {
        from: "roles",
        localField: "role_id",
        foreignField: "_id",
        as: "role"
      }
    },
    {
      $unwind: "$role"
    },
    {
      $lookup: {
        from: "role_permissions",
        localField: "role._id",
        foreignField: "role_id",
        as: "role_permissions"
      }
    },
    {
      $unwind: "$role_permissions"
    },
    {
      $lookup: {
        from: "permissions",
        localField: "role_permissions.permission_id",
        foreignField: "_id",
        as: "permission"
      }
    },
    {
      $unwind: "$permission"
    },
    {
      $match: {
        "permission.resource": resource,
        "permission.action": action
      }
    },
    {
      $project: {
        has_permission: true,
        permission_name: "$permission.name",
        role_name: "$role.name"
      }
    }
  ]).toArray();

  return {
    allowed: permissions.length > 0,
    permissions: permissions
  };
};

QueryLeaf Integration with Atlas App Services

QueryLeaf can seamlessly work with Atlas App Services to provide SQL interfaces for serverless applications:

-- QueryLeaf can generate Atlas Functions from SQL procedures
CREATE OR REPLACE FUNCTION get_user_dashboard_data(user_id UUID)
RETURNS TABLE (
  user_profile JSONB,
  recent_orders JSONB,
  recommendations JSONB,
  analytics JSONB
) AS $$
BEGIN
  -- This gets translated to Atlas App Services function
  RETURN QUERY
  WITH user_data AS (
    SELECT 
      u.name,
      u.email,
      u.preferences,
      u.loyalty_points
    FROM users u
    WHERE u._id = user_id
  ),
  order_data AS (
    SELECT json_agg(
      json_build_object(
        'order_id', o._id,
        'total', o.total,
        'status', o.status,
        'created_at', o.created_at
      ) ORDER BY o.created_at DESC
    ) AS recent_orders
    FROM orders o
    WHERE o.user_id = user_id
    AND o.created_at >= CURRENT_DATE - INTERVAL '30 days'
    LIMIT 10
  ),
  recommendation_data AS (
    SELECT json_agg(
      json_build_object(
        'product_id', p._id,
        'name', p.name,
        'price', p.price,
        'score', r.score
      ) ORDER BY r.score DESC
    ) AS recommendations
    FROM product_recommendations r
    JOIN products p ON r.product_id = p._id
    WHERE r.user_id = user_id
    LIMIT 5
  )
  SELECT 
    row_to_json(user_data.*) AS user_profile,
    order_data.recent_orders,
    recommendation_data.recommendations,
    json_build_object(
      'total_orders', (SELECT COUNT(*) FROM orders WHERE user_id = user_id),
      'total_spent', (SELECT SUM(total) FROM orders WHERE user_id = user_id)
    ) AS analytics
  FROM user_data, order_data, recommendation_data;
END;
$$ LANGUAGE plpgsql;

-- QueryLeaf automatically converts this to Atlas App Services function
-- Call the function using familiar SQL syntax
SELECT * FROM get_user_dashboard_data('507f1f77bcf86cd799439011');

Performance Optimization for Serverless Functions

Function Caching Strategies

// Atlas Function: Cached Product Catalog
const CACHE_TTL = 300; // 5 minutes
let catalogCache = null;
let cacheTimestamp = 0;

exports = async function(category, limit = 20) {
  const now = Date.now();

  // Check cache validity like SQL query caching
  if (catalogCache && (now - cacheTimestamp) < (CACHE_TTL * 1000)) {
    return filterCachedResults(catalogCache, category, limit);
  }

  const mongodb = context.services.get("mongodb-atlas");
  const db = mongodb.db("catalog");

  // SQL-style aggregation with caching
  catalogCache = await db.collection("products").aggregate([
    {
      $match: { 
        status: "active",
        inventory_count: { $gt: 0 }
      }
    },
    {
      $lookup: {
        from: "categories",
        localField: "category_id",
        foreignField: "_id",
        as: "category"
      }
    },
    {
      $unwind: "$category"
    },
    {
      $project: {
        name: 1,
        price: 1,
        category_name: "$category.name",
        inventory_count: 1,
        rating: 1,
        popularity_score: {
          $add: [
            { $multiply: ["$view_count", 0.3] },
            { $multiply: ["$purchase_count", 0.7] }
          ]
        }
      }
    },
    { $sort: { popularity_score: -1 } }
  ]).toArray();

  cacheTimestamp = now;

  return filterCachedResults(catalogCache, category, limit);
};

function filterCachedResults(cache, category, limit) {
  let results = cache;

  if (category) {
    results = cache.filter(product => product.category_name === category);
  }

  return results.slice(0, limit);
}

Batch Processing Patterns

// Atlas Function: Batch Order Processing
exports = async function() {
  const mongodb = context.services.get("mongodb-atlas");
  const db = mongodb.db("ecommerce");

  // SQL-style batch processing with transactions
  const session = mongodb.startSession();

  try {
    session.startTransaction();

    // Get pending orders like SQL SELECT FOR UPDATE
    const pendingOrders = await db.collection("orders")
      .find({ 
        status: "pending",
        created_at: { $lt: new Date(Date.now() - 60000) } // 1 minute old
      })
      .limit(100)
      .toArray();

    const batchResults = [];

    for (const order of pendingOrders) {
      try {
        // Process each order with SQL-style logic
        const processResult = await processOrder(db, order, session);
        batchResults.push({
          order_id: order._id,
          status: 'processed',
          result: processResult
        });

      } catch (error) {
        batchResults.push({
          order_id: order._id,
          status: 'failed',
          error: error.message
        });
      }
    }

    await session.commitTransaction();

    return {
      processed: batchResults.length,
      successful: batchResults.filter(r => r.status === 'processed').length,
      failed: batchResults.filter(r => r.status === 'failed').length,
      results: batchResults
    };

  } catch (error) {
    await session.abortTransaction();
    throw error;
  } finally {
    session.endSession();
  }
};

async function processOrder(db, order, session) {
  // SQL-style order processing logic
  const paymentResult = await context.functions.execute(
    "processPayment", 
    order._id, 
    order.total, 
    order.payment_method
  );

  if (paymentResult.status === 'success') {
    await db.collection("orders").updateOne(
      { _id: order._id },
      { 
        $set: { 
          status: 'confirmed',
          payment_id: paymentResult.payment_id,
          confirmed_at: new Date()
        }
      },
      { session }
    );

    return { payment_id: paymentResult.payment_id };
  } else {
    throw new Error(`Payment failed: ${paymentResult.error}`);
  }
}

Best Practices for Atlas App Services

Function Design: Keep functions focused and single-purpose like SQL stored procedures
Error Handling: Implement comprehensive error handling with meaningful messages
Security: Use App Services rules for data access control and authentication
Performance: Leverage caching and batch processing for optimal performance
Monitoring: Implement logging and metrics collection for production visibility
Testing: Develop comprehensive test suites for serverless functions

Conclusion

MongoDB Atlas App Services provides a powerful serverless platform that simplifies application development while maintaining the performance and scalability characteristics needed for production systems. By approaching serverless development with SQL-familiar patterns, teams can leverage their existing expertise while gaining the benefits of serverless architecture.

Key advantages of SQL-style serverless development:

Familiar Patterns: Use well-understood SQL concepts for business logic
Integrated Platform: Combine database, authentication, and compute in a single service
Automatic Scaling: Handle traffic spikes without infrastructure management
Cost Efficiency: Pay only for actual function execution time
Developer Productivity: Focus on business logic instead of infrastructure concerns

Whether you're building e-commerce platforms, content management systems, or data processing applications, Atlas App Services with SQL-style patterns provides a robust foundation for modern serverless applications.

The combination of MongoDB's document flexibility, Atlas's managed infrastructure, and QueryLeaf's familiar SQL interface creates an ideal environment for rapid development and deployment of scalable serverless applications.

With proper design patterns, security implementation, and performance optimization, Atlas App Services enables you to build enterprise-grade serverless applications that maintain the development velocity and operational simplicity that modern teams require.