Skip to main content

​
Overview

Understanding an existing codebase — for an audit, due diligence, a modernization push, or a system you inherited — traditionally requires months of manual analysis. Zenable provides automated deep-dive analysis that maps dependencies, identifies risks, and creates implementation roadmaps - giving you complete understanding of your code in hours, not months.
The Zenable Assessment skill is coming soon. A guided, interview-driven assessment for your coding agent: it helps you co-author custom requirements, runs a two-pass scan (deterministic checks plus an AI review against the same requirements), and produces a polished, evidence-backed report you can upload and share in the Zenable app — while bootstrapping your tenant with the requirements, scopes, and guardrails you defined along the way.Email hello@zenable.io to get early access.

​
Out-of-the-Box Analysis

Zenable automatically detects these code issues:

Standard Code Assessment Checks

  • Code Smells - Deep nesting, long methods, duplicate code
  • Outdated Patterns - Deprecated APIs, obsolete libraries
  • Security Vulnerabilities - SQL injection, hardcoded secrets, weak crypto
  • Technical Debt - Missing tests, poor documentation, cyclomatic complexity
  • Dead Code - Unused functions, unreachable code
  • Performance Issues - N+1 queries, inefficient algorithms

​
Custom Organization Requirements

Apply your specific modernization criteria:
“All of our services must be migrated to our new microservices architecture, use our internal authentication service, follow our naming conventions, and include telemetry with our monitoring stack.”

​
In Action

# Run a comprehensive assessment, including custom requirements
zenable check '**/*'

​
Custom Modernization Examples

​
Example: Microservices Migration

Your Policy: “All monolithic components must be refactored into domain-bounded microservices” 
# ❌ Existing monolith
class UserService:
    def create_user(self, data):
        user = self.validate_user(data)
        self.send_email(user.email)  # Mixing concerns
        self.update_inventory(user)  # Unrelated domain
        self.log_analytics(user)     # Another concern
        return user

# ✅ Zenable suggests microservices refactor
class UserService:
    def create_user(self, data):
        user = self.validate_user(data)
        event_bus.publish("user.created", user)
        return user

# Separate services handle their domains
# EmailService, InventoryService, AnalyticsService

​
Example: Internal Standards Migration

Your Policy: “Replace all direct database calls with our DataAccess layer” 
// ❌ Direct DB access
function getUser(id) {
    const result = db.query(`SELECT * FROM users WHERE id = ${id}`);
    return result[0];
}

// ✅ Zenable enforces your data layer
function getUser(id) {
    return DataAccess.users.findById(id, {
        cache: true,
        metrics: true,
        audit: true
    });
}

​
Example: Tech Stack Modernization

Your Policy: “Migrate from jQuery to React, replace callback patterns with async/await” 
// ❌ Aging jQuery code
$(document).ready(function() {
    $.ajax({
        url: '/api/data',
        success: function(data) {
            $('#result').html(data);
        }
    });
});

// ✅ Zenable suggests modern React
import { useState, useEffect } from 'react';

function DataComponent() {
    const [data, setData] = useState(null);

    useEffect(() => {
        const fetchData = async () => {
            const response = await fetch('/api/data');
            setData(await response.json());
        };
        fetchData();
    }, []);

    return <div>{data}</div>;
}

​
Example: Observability Requirements

Your Policy: “All services must add distributed tracing and structured logging” 
# ❌ No observability
def process_payment(amount):
    result = payment_gateway.charge(amount)
    return result

# ✅ Zenable adds your observability
from opentelemetry import trace
from structlog import get_logger

tracer = trace.get_tracer(__name__)
logger = get_logger()

def process_payment(amount):
    with tracer.start_as_current_span("process_payment") as span:
        span.set_attribute("payment.amount", amount)

        logger.info("payment.started", amount=amount)
        result = payment_gateway.charge(amount)

        logger.info("payment.completed",
                   amount=amount,
                   transaction_id=result.id)

        return result

​
Benefits

  • Complete Tech Debt Understanding - Know exactly what needs modernization
  • Custom Migration Path - Enforce your specific architectural standards
  • Risk-Based Prioritization - Focus on critical issues first
  • Accelerated Modernization - Move from months to hours of analysis