DEV Community: Mike Clarke

Mastering the Flow: How to Configure a Smart Traffic System

Mike Clarke — Wed, 16 Sep 2026 06:00:18 +0000

Hey folks!

Ever found yourself stuck in a gridlocked city, wishing someone had a better handle on the traffic lights? Or maybe you've worked on a distributed system and realized that managing resource contention is a lot like optimizing traffic flow. In either case, the problem is real: how to configure a smart traffic system to keep things moving efficiently, prevent bottlenecks, and adapt to changing conditions.

Traditional traffic light systems are often time-based, cycling through greens and reds without much regard for actual vehicle presence or density. Smart traffic systems, on the other hand, are dynamic. They leverage sensors, data analytics, and often AI/ML to make real-time decisions, optimizing flow, reducing emissions, and improving safety. For us developers, this isn't just about civic planning; it's a fascinating challenge in distributed systems, real-time data processing, and intelligent control.

The Core Concept: Dynamic Optimization

At its heart, configuring a smart traffic system involves creating an intelligent agent that can observe traffic conditions, predict future states, and issue commands to traffic signals. Think of it as a control loop:

Observe: Gather data from sensors (e.g., inductive loops, cameras, lidar) at intersections, detecting vehicle presence, speed, and queue length.
Analyze & Predict: Process this data. Are there long queues on one road? Is an emergency vehicle approaching? Use algorithms to predict future traffic density and potential congestion points.
Decide: Based on analysis, determine the optimal signal timings for each phase at an intersection, or even coordinate multiple intersections. This might involve optimizing for minimal waiting time, maximum throughput, or priority for certain vehicles.
Act: Send commands to the traffic light controllers to adjust their patterns.

This cycle repeats continuously, adapting to the ebb and flow of urban life. The 'smart' part comes from the complexity of the decision-making logic, often involving techniques like reinforcement learning, genetic algorithms, or even simple heuristic-based rules. The challenge is balancing conflicting demands – giving green to one direction often means red for another. It's a zero-sum game that needs careful arbitration.

Pseudocode: A Glimpse into the Brain

Let's sketch out a very simplified conceptual model for a single intersection with four approaches (North, East, South, West):

CLASS TrafficController:
    ATTRIBUTES:
        sensors: Map<Direction, List<SensorData>>  // Vehicle counts, speeds per lane
        signals: Map<Direction, TrafficSignal> // Green, Yellow, Red states
        current_phase: TrafficPhase // e.g., N-S Green, E-W Red
        phase_timer: Timer
        min_green_time: Integer
        max_green_time: Integer

    METHOD initialize():
        SET current_phase = default_phase
        START phase_timer with min_green_time

    METHOD update_traffic_data(new_sensor_data):
        sensors.update(new_sensor_data)

    METHOD decide_next_phase():
        IF phase_timer.elapsed() >= min_green_time THEN
            // Calculate priority scores for each potential next phase
            priority_scores = calculate_priority_for_all_phases(sensors.data)

            // Example: Prioritize phase with highest queue length
            next_phase_candidate = find_phase_with_highest_priority(priority_scores)

            IF next_phase_candidate != current_phase AND 
               phase_timer.elapsed() >= calculate_optimal_duration(current_phase, sensors.data) THEN
                INITIATE transition_to_phase(next_phase_candidate)
            ELSE IF phase_timer.elapsed() >= max_green_time THEN
                // Force transition if max green time reached
                INITIATE transition_to_phase(next_phase_candidate)
            END IF
        END IF

    METHOD transition_to_phase(new_phase):
        signals.set_yellow(current_phase) // Short yellow transition
        WAIT for yellow_duration
        signals.set_red(current_phase)
        signals.set_green(new_phase)
        SET current_phase = new_phase
        RESTART phase_timer

    METHOD calculate_priority_for_all_phases(data):
        // This is where the 'smart' algorithms go:
        // - Count vehicles waiting for each phase
        // - Consider emergency vehicle alerts
        // - Factor in pedestrian requests
        // - Apply weighted heuristics or ML model predictions
        RETURN map_of_phase_to_priority_score

    METHOD calculate_optimal_duration(current_phase, data):
        // Determine how long the current green should extend
        // - Based on current queue reduction
        // - Anticipated incoming traffic
        RETURN duration_in_seconds

This pseudocode scratches the surface. A real system would involve networking, fault tolerance, multi-intersection coordination, and a robust data pipeline. But it illustrates the core decision-making loop.

Why Practice Matters in Smart Systems

Reading about smart traffic systems is one thing; actually designing and configuring one is another. The devil is in the details: sensor accuracy, latency in communication, the subtle tuning of algorithms to avoid oscillation (e.g., lights flipping too quickly), and handling edge cases like sensor failures or sudden spikes in traffic. You need to understand how your decisions impact the system's behavior, often in non-obvious ways.

Experimenting with different configuration parameters, testing various algorithms, and seeing their impact on simulated traffic flow is crucial. It’s where you truly internalize the trade-offs and complexities involved in making a system truly smart and resilient. This kind of hands-on experience builds intuition that no amount of theoretical reading can replace.

Ready to Build Smarter Cities?

The journey from concept to a functioning smart traffic system is filled with intriguing challenges. It's a perfect playground for applying your programming and problem-solving skills to real-world, impactful problems. Get your hands dirty, tweak some parameters, and see the digital cars flow!

Practice this concept interactively on CodeCityApp — free trial at codecityapp.com

Originally published on CodeCityApp

Smart Traffic Configuration: Your Guide to Smarter City Systems

Mike Clarke — Wed, 09 Sep 2026 06:00:17 +0000

Smart Traffic Configuration: Your Guide to Smarter City Systems

Hey fellow developers,

Ever found yourself stuck in a gridlock, wishing the traffic lights just knew what was going on? Or maybe you've tried to navigate a city during peak hour and felt like the urban planning was stuck in the last century. That's not just a personal frustration; it's a massive, real-world problem that smart traffic systems aim to solve. And as developers, we're the ones building them.

Today, we're diving into the nitty-gritty of how to configure the smart traffic system – not just the theoretical 'what if', but the practical 'how-to' that moves us closer to dynamic, responsive urban infrastructure.

The Gridlock Problem: Why Smart Traffic Matters

Traditional traffic systems are often static, time-based, or rely on simple loop detectors. They don't adapt well to unexpected events like accidents, sudden influxes of vehicles due to a concert, or even just daily fluctuations in commute patterns. The result? Wasted fuel, increased pollution, stressed commuters, and lost productivity.

Smart traffic systems, on the other hand, leverage data, algorithms, and real-time communication to optimize traffic flow. They're about making decisions on the fly, reducing congestion, and improving safety. From intelligent signal timing to adaptive route guidance, these systems are the brains behind a smoother, greener city.

Understanding the Core Concepts: What Are We Configuring?

At its heart, configuring a smart traffic system involves setting up rules, parameters, and algorithms that dictate how traffic lights, signs, and even autonomous vehicles interact. Here are the key components we typically configure:

Sensor Data Ingestion: This is the input. We're talking about data from cameras (vehicle counts, speed, occupancy), inductive loops, GPS trackers, and even mobile device data. The system needs to know what's happening now.
Traffic Light Control Logic: This is the brain. Instead of fixed timers, we implement dynamic algorithms. These might be based on machine learning models predicting congestion, optimization algorithms like greedy approaches, or even reinforcement learning agents that 'learn' optimal signal timings.
Prioritization Rules: Think emergency vehicles, public transport, or high-volume thoroughfares. We configure priorities to ensure critical movements are facilitated.
Network-wide Optimization: It's not just about one intersection; it's about optimizing flow across an entire urban grid. This involves coordinating signals between adjacent intersections to create 'green waves' and prevent blockages downstream.
Anomaly Detection & Response: Configuration includes rules for identifying incidents (accidents, stalled vehicles) and triggering appropriate responses, such as adjusting signal timings, displaying alerts on variable message signs, or dispatching emergency services.
Simulation & Testing Parameters: Before deploying anything live, we simulate various scenarios. Configuring these simulation environments and tuning parameters is crucial for validation.

Pseudocode: A Glimpse into Dynamic Signal Control

Let's consider a simplified pseudocode example for dynamic signal timing at a single intersection based on vehicle counts:

// System Configuration Variables
SET MIN_GREEN_TIME = 15 // seconds
SET MAX_GREEN_TIME = 60 // seconds
SET DETECTION_INTERVAL = 5 // seconds, how often sensors are read
SET CONGESTION_THRESHOLD = 20 // vehicles, for a lane

// Intersection State
DECLARE current_phase = 'NORTH_SOUTH'
DECLARE north_south_vehicle_count = 0
DECLARE east_west_vehicle_count = 0
DECLARE phase_timer = 0

// Main Loop for Traffic Light Controller
FUNCTION run_traffic_controller():
  WHILE TRUE:
    // Read sensor data
    north_south_vehicle_count = GET_SENSOR_DATA('NORTH_SOUTH_APPROACH')
    east_west_vehicle_count = GET_SENSOR_DATA('EAST_WEST_APPROACH')

    // Increment phase timer
    phase_timer = phase_timer + DETECTION_INTERVAL

    IF current_phase == 'NORTH_SOUTH':
      IF phase_timer >= MIN_GREEN_TIME:
        IF east_west_vehicle_count > CONGESTION_THRESHOLD AND north_south_vehicle_count < (east_west_vehicle_count / 2):
          // Switch to East-West if heavy congestion there and NS is light
          TRIGGER_YELLOW_LIGHT('NORTH_SOUTH')
          WAIT(3) // Yellow light duration
          current_phase = 'EAST_WEST'
          phase_timer = 0
        ELSE IF phase_timer >= MAX_GREEN_TIME:
          // Force switch if max green time reached
          TRIGGER_YELLOW_LIGHT('NORTH_SOUTH')
          WAIT(3)
          current_phase = 'EAST_WEST'
          phase_timer = 0
      END IF
      SET_LIGHTS('NORTH_SOUTH', 'GREEN')
      SET_LIGHTS('EAST_WEST', 'RED')

    ELSE IF current_phase == 'EAST_WEST':
      IF phase_timer >= MIN_GREEN_TIME:
        IF north_south_vehicle_count > CONGESTION_THRESHOLD AND east_west_vehicle_count < (north_south_vehicle_count / 2):
          // Switch to North-South
          TRIGGER_YELLOW_LIGHT('EAST_WEST')
          WAIT(3)
          current_phase = 'NORTH_SOUTH'
          phase_timer = 0
        ELSE IF phase_timer >= MAX_GREEN_TIME:
          // Force switch
          TRIGGER_YELLOW_LIGHT('EAST_WEST')
          WAIT(3)
          current_phase = 'NORTH_SOUTH'
          phase_timer = 0
      END IF
      SET_LIGHTS('EAST_WEST', 'GREEN')
      SET_LIGHTS('NORTH_SOUTH', 'RED')

    WAIT(DETECTION_INTERVAL)
  END WHILE
END FUNCTION

This pseudocode illustrates a basic reactive system. Real-world systems are far more complex, incorporating predictive models, multi-intersection coordination, and robust error handling. But the fundamental idea is to use data to dynamically adjust parameters.

Why Practice Configuration Matters

Reading about MIN_GREEN_TIME or CONGESTION_THRESHOLD is one thing; actually seeing how changes to these values impact traffic flow is another. Misconfiguring a smart traffic system can have disastrous consequences – creating new bottlenecks, increasing accident risk, or even bringing a city to a standstill. That's why hands-on practice, experimentation in a safe environment, and understanding the nuances of parameter tuning are absolutely essential for any developer working in this domain.

Experimenting with different algorithms, tweaking thresholds, and observing the system's response in various simulated scenarios builds intuition and expertise that no amount of theoretical reading can provide. It prepares you for the complex, ever-changing demands of urban environments.

Practice this concept interactively on CodeCityApp — free trial at codecityapp.com

Originally published on CodeCityApp

Demystifying Smart Traffic: How to Configure an Intelligent System

Mike Clarke — Wed, 02 Sep 2026 06:00:15 +0000

Hey fellow devs!

Ever found yourself stuck in a gridlock, wishing the traffic lights just knew what was going on? That’s not just a pipe dream; it's the very problem we're solving with smart traffic systems. Configuring one isn't about simply setting timers; it's about building an intelligent, adaptive network that responds to real-time conditions. This isn't just theory – it's a fascinating challenge that blends data science, IoT, and control systems.

The Problem: Static Traffic Control is Obsolete

Traditional traffic light systems operate on fixed cycles, often optimized for peak hours or historical averages. But what happens when there's an accident, a sudden surge in pedestrian traffic, or a special event? These static systems fail spectacularly, leading to congestion, increased pollution, and frustrated commuters. As cities grow, the inefficiency compounds, making a strong case for dynamic, intelligent solutions.

Our mission, should we choose to accept it, is to build a system that can:

Sense: Gather real-time data from various sources.
Analyze: Process that data to understand current traffic flow and predict future trends.
Adapt: Dynamically adjust traffic signals and other controls to optimize flow.
Learn: Improve its performance over time through machine learning.

The Concept: An Adaptive Ecosystem

At its core, configuring a smart traffic system means orchestrating a symphony of sensors, data pipelines, decision-making algorithms, and actuators. Think of it like this:

Data Ingestion (The Eyes and Ears): This is where real-time information streams in. We're talking about magnetic loop detectors embedded in the road, cameras performing vehicle counting and classification (potentially even recognizing emergency vehicles), GPS data from connected vehicles, pedestrian sensors, and even weather reports.
Data Processing & Fusion (The Brain's Cortex): Raw sensor data is noisy and disparate. We need to clean, normalize, and combine it. This might involve spatial temporal analysis to understand traffic density across junctions, identifying queues, and calculating average speeds. Edge computing can play a vital role here, processing data closer to the source to reduce latency.
Decision-Making Engine (The Logic Core): This is where the 'smart' truly happens. Algorithms, ranging from simple rule-based systems to complex Reinforcement Learning (RL) agents, take the processed data and decide the optimal course of action. Should the green light duration on Main Street be extended? Should a turn lane be prioritized? This engine aims to minimize overall travel time, reduce idle time, and manage congestion.
Actuation & Feedback (The Hands and Mouth): Once a decision is made, commands are sent to the traffic signal controllers, variable message signs, or even integrated public transport systems. The system then continuously monitors the impact of its decisions, feeding new data back into the cycle for continuous improvement.

A Glimpse into the Code: The Decision-Making Loop (Pseudocode)

Let’s imagine a simplified decision engine for a single intersection. This pseudocode demonstrates the iterative nature of the system:

FUNCTION configureSmartTrafficSystem():
    INITIALIZE trafficSignalControllers
    INITIALIZE dataAggregator
    INITIALIZE decisionEngine
    INITIALIZE learningModule

    WHILE systemIsRunning:
        // 1. Gather Real-time Data
        trafficData = dataAggregator.collectSensorData()

        // 2. Process and Analyze Data
        processedTrafficState = decisionEngine.analyzeTrafficState(trafficData)

        // 3. Make a Decision
        IF learningModule.isReadyForAdvancedDecision():
            // Use RL or predictive models for complex scenarios
            newSignalPlan = learningModule.predictOptimalSignalPlan(processedTrafficState)
        ELSE:
            // Fallback to rule-based or simpler algorithms
            newSignalPlan = decisionEngine.calculateRuleBasedSignalPlan(processedTrafficState)
        END IF

        // 4. Actuate Control
        trafficSignalControllers.applySignalPlan(newSignalPlan)

        // 5. Monitor and Learn (asynchronously or in background)
        performanceMetrics = trafficSignalControllers.getPerformanceMetrics()
        learningModule.updateModel(processedTrafficState, newSignalPlan, performanceMetrics)

        WAIT_FOR_NEXT_CYCLE_OR_EVENT()
    END WHILE
END FUNCTION

// Example of a dataAggregator method
CLASS DataAggregator:
    METHOD collectSensorData():
        sensorReadings = {}
        FOR EACH sensor IN listOfSensors:
            sensorReadings[sensor.id] = sensor.readData()
        END FOR
        RETURN sensorReadings
END CLASS

// Example of a simple rule-based decision engine method
CLASS DecisionEngine:
    METHOD calculateRuleBasedSignalPlan(state):
        IF state.majorRoadQueueLength > state.minorRoadQueueLength * 2:
            RETURN { 'majorRoadGreenDuration': 60, 'minorRoadGreenDuration': 15 }
        ELSE IF state.pedestrianCrossingsRequested:
            RETURN { 'pedestrianCrossWalkTime': 20, 'vehicleLightsRed': True }
        ELSE:
            RETURN { 'majorRoadGreenDuration': 30, 'minorRoadGreenDuration': 30 }
        END IF
    END METHOD
END CLASS

This isn't a full solution, but it illustrates the logical flow: sense, process, decide, act, and learn. Each component can be a complex system in itself, using everything from Kafka streams for data ingestion to TensorFlow for deep reinforcement learning.

Why Practice Matters in This Domain

Understanding these concepts abstractly is one thing; actually seeing how data flows, how algorithms react to changing conditions, and how different configurations impact system performance is another. Traffic simulation environments are invaluable here. They allow you to experiment with different sensor placements, test various decision algorithms (e.g., comparing fixed-time, actuated, and AI-driven approaches), and observe the emergent behavior of the system under diverse traffic patterns without deploying a single sensor in the real world.

This hands-on approach helps you grasp the nuances of latency, data integrity, algorithm tuning, and the sheer complexity of optimizing for multiple, often conflicting, objectives (e.g., minimizing average wait time vs. ensuring emergency vehicle priority).

Configuring a smart traffic system is a multidisciplinary engineering feat. It's challenging, but incredibly rewarding, as you're directly contributing to more efficient, sustainable, and livable cities.

Practice this concept interactively on CodeCityApp — free trial at codecityapp.com

Originally published on CodeCityApp

Your AI generated hundreds of pieces of content. None of it ever shipped.

Mike Clarke — Fri, 14 Aug 2026 14:00:06 +0000

Your AI generated hundreds of pieces of content. None of it ever shipped.

Key Takeaways

A queue in a ready state is not done. Done means consumed and delivered.
Generation and publication are two separate stages. An automated bridge between them is not optional.
Any queue without a consumer and a depth alert is a silent failure waiting to accumulate.
"The work looks done" is the most dangerous state in an autonomous system.

In ARIA — the autonomous content operations system we run at Elevare Digital — we watched two queues quietly fill up over time. Content was being generated. It was landing in the database in a ready state. Every upstream metric looked fine.

None of it ever reached the destination. Not a single item.

The root cause was not a bug. It was a design assumption that never got questioned: publication was a manual step, and nobody ran it.

What the system looked like

ARIA's content pipeline has two distinct stages. Stage one: generation. The agents do their work, write the content, and mark the row ready. Stage two: publication. Something takes those ready rows and pushes them out.

Stage one was fully automated. Stage two was manual by design — a decision that made sense early on when we wanted a human in the loop before anything shipped publicly.

The problem is that "manual by design" eventually became "never runs." There was no consumer process watching the queue. There was no alert watching the queue depth. The count just grew.

-- What we were looking at in Supabase:
-- content_queue table, simplified

CREATE TABLE content_queue (
  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
  content_id uuid REFERENCES content(id),
  status text NOT NULL DEFAULT 'pending',
  -- statuses: pending | generating | ready | published | failed
  created_at timestamptz DEFAULT now(),
  updated_at timestamptz DEFAULT now()
);

-- The generation side was automated and ran correctly.
-- Items moved from 'pending' -> 'generating' -> 'ready'.
-- Nothing moved them from 'ready' -> 'published'.
-- The query below returned a number that kept growing:

SELECT COUNT(*) FROM content_queue WHERE status = 'ready';

That count was not a success metric. It was a backlog. We were reading it as one and ignoring the other.

Why this is easy to miss

When you look at a pipeline dashboard and see items flowing into ready, it feels like progress. The agents are working. The generation numbers are up. The logs are clean.

The gap between ready and published is invisible unless you specifically instrument it. We hadn't. There was no metric on queue depth over time, no alert threshold, nothing that would fire if ready stopped draining.

This is the specific failure mode:

// Pseudocode for what ARIA's generation side was doing — correctly:
async function generateContent(jobId: string) {
  await updateStatus(jobId, 'generating');
  const content = await runGenerationAgents(jobId);
  await saveContent(content);
  await updateStatus(jobId, 'ready'); // <-- work stops here
  // Nothing downstream is listening. This is a dead end.
}

// What the publication side needed but didn't have:
async function publishConsumer() {
  // This function did not exist as an automated process.
  // It existed as a manual script someone had to remember to run.
  const readyItems = await getItemsByStatus('ready');
  for (const item of readyItems) {
    await publish(item);
    await updateStatus(item.id, 'published');
  }
}

The generation function had no idea there was no consumer on the other end. It just kept doing its job.

The fix: every queue gets a consumer and a depth alert

The rule we applied after this: no queue exists without two things attached to it.

An automated consumer that drains it.
A depth alert that fires if items in a terminal-waiting state (like ready) exceed a threshold for too long.

The consumer can be a Deno edge function on a schedule, a Supabase pg_cron job, a webhook trigger — the mechanism matters less than the guarantee that something is watching and pulling.

-- pg_cron job that checks for stranded 'ready' items
-- and alerts if the queue hasn't drained

-- First, a view that makes the staleness visible:
CREATE VIEW stranded_content AS
SELECT
  id,
  content_id,
  status,
  updated_at,
  now() - updated_at AS time_in_state
FROM content_queue
WHERE
  status = 'ready'
  AND updated_at < now() - INTERVAL '2 hours';

-- Then a function that pages someone if this view has rows:
CREATE OR REPLACE FUNCTION alert_on_stranded_queue()
RETURNS void AS $$
DECLARE
  stranded_count integer;
BEGIN
  SELECT COUNT(*) INTO stranded_count FROM stranded_content;

  IF stranded_count > 0 THEN
    -- Call your alerting mechanism here.
    -- We use a Supabase edge function that posts to our ops channel.
    PERFORM net.http_post(
      url := current_setting('app.alert_webhook_url'),
      body := json_build_object(
        'message', format('%s items stranded in ready state', stranded_count),
        'severity', 'warning'
      )::text,
      headers := '{"Content-Type": "application/json"}'
    );
  END IF;
END;
$$ LANGUAGE plpgsql;

-- Schedule it:
SELECT cron.schedule(
  'check-stranded-queue',
  '*/30 * * * *', -- every 30 minutes
  'SELECT alert_on_stranded_queue()'
);

The threshold and interval depend on your expected throughput. The point is that a human gets paged before the count becomes embarrassing.

The lesson isn't about the bug

This wasn't a bug in the traditional sense. The code did exactly what it was written to do. Generation worked. The ready status was accurate. The manual publication step was documented.

The failure was architectural: we treated "generated" as a proxy for "shipped" without building anything to enforce the difference.

In an autonomous pipeline, every state transition needs an owner. If the transition from ready to published requires a human action, then the system needs to demand that action — not wait quietly while the queue fills.

A full queue is not progress. It's generated work that went nowhere. The two look identical from the outside until you add the one metric that matters: how long has this item been waiting, and who knows about it?

— Mike Clarke, founder of Elevare Digital.

Configuring Smart Traffic Systems: A Developer's Deep Dive

Mike Clarke — Wed, 12 Aug 2026 06:00:21 +0000

As developers, we often tackle complex problems, and few are as dynamic and critical as managing urban traffic. The constant ebb and flow of vehicles, pedestrians, and public transport presents a fascinating challenge. If you've ever stared at a gridlocked intersection and thought, "There has to be a better way," then you're already thinking like a smart traffic system architect. Today, we're diving into how to configure a smart traffic system – not just the fancy AI, but the foundational logic that makes it tick.

The Gridlock Dilemma: Why Smart Systems Matter

Traditional traffic light systems are, for the most part, static. They operate on pre-defined timers, regardless of actual traffic density. This leads to frustrating scenarios: an empty main road gets a long green light while a dozen cars wait impatiently on a side street, or vice-versa. This inefficiency isn't just annoying; it costs time, wastes fuel, increases pollution, and can even delay emergency services.

The goal of a smart traffic system is to move beyond these fixed schedules. It aims for dynamic, adaptive control, optimizing traffic flow in real-time. This isn't just about making commutes smoother; it's about building more efficient, sustainable, and responsive cities.

The Core Concept: Sensors, Logic, and Actuation

At its heart, a smart traffic system is a feedback loop. It observes, decides, and acts. Here's a breakdown:

Sensing (Input): This is where data is collected. Inductive loops embedded in the road, cameras with computer vision capabilities, radar, and even connected vehicle data can tell the system about vehicle presence, speed, queue length, and pedestrian crossings.
Processing/Logic (Decision): This is the brain of the operation. Based on the data from the sensors, the system's algorithms decide the optimal traffic light phasing. Simple systems might use rule-based logic (e.g., "if queue on street A > 5 and queue on street B < 2, extend green for A"). More advanced systems employ machine learning models to predict traffic patterns or reinforce learning agents to dynamically learn optimal strategies.
Actuation (Output): Once a decision is made, the system controls the traffic signals. This involves sending commands to change light states (red, yellow, green) and their durations.

Configuring such a system involves defining these relationships, setting thresholds, and refining the algorithms. It's less about hard-coding every single scenario and more about building a flexible, adaptable framework.

Pseudocode Snapshot: A Simple Adaptive Intersection

Let's consider a basic 4-way intersection. Our goal is to dynamically adjust green light times based on detected traffic volume. We'll use a TrafficLight object for each approach and a Sensor object to detect vehicles.

// Define a simplified TrafficLight object
class TrafficLight:
    constructor(id, initial_state, min_green_time, max_green_time)
    method set_state(new_state)
    method get_current_state()

// Define a simplified Sensor object
class Sensor:
    constructor(location_id)
    method get_vehicle_count() // Returns number of vehicles detected
    method get_queue_length() // Returns estimated queue length

// Main Traffic Management System Logic
function configure_smart_intersection(intersection_id, approaches):
    // approaches: a map from approach_id (e.g., 'north_bound') to a tuple of (TrafficLight, Sensor)

    current_green_approach = 'north_bound' // Start with a default
    timer_for_current_approach = 0

    loop indefinitely:
        // 1. Get current traffic data
        traffic_data = {}
        for approach_id, (light, sensor) in approaches.items():
            traffic_data[approach_id] = {
                'vehicle_count': sensor.get_vehicle_count(),
                'queue_length': sensor.get_queue_length()
            }

        // 2. Apply Decision Logic
        current_light, current_sensor = approaches[current_green_approach]

        // Check if current green time has exceeded minimum or if other approaches demand attention
        if timer_for_current_approach >= current_light.min_green_time:
            // Look for approaches with significant queues that aren't currently green
            candidate_next_approach = null
            max_queue = 0

            for other_approach_id, (other_light, other_sensor) in approaches.items():
                if other_approach_id != current_green_approach:
                    if other_sensor.get_queue_length() > max_queue:
                        max_queue = other_sensor.get_queue_length()
                        candidate_next_approach = other_approach_id

            // If a significant queue is detected elsewhere OR max_green_time is reached
            if (candidate_next_approach != null and max_queue > THRESHOLD_FOR_SWITCH) or 
               timer_for_current_approach >= current_light.max_green_time:
                // Initiate switch sequence (e.g., yellow for current, then red, then green for next)
                // (Simplified for pseudocode)
                current_light.set_state('YELLOW')
                wait(YELLOW_DURATION)
                current_light.set_state('RED')

                current_green_approach = candidate_next_approach // Or pick based on priority
                next_light, _ = approaches[current_green_approach]
                next_light.set_state('GREEN')
                timer_for_current_approach = 0
            else:
                // Extend current green light
                timer_for_current_approach += TIME_STEP
        else:
            // Must complete minimum green time
            timer_for_current_approach += TIME_STEP

        wait(TIME_STEP) // Simulate time passing

This pseudocode illustrates a basic reactive system. Real-world systems incorporate predictive models, coordination between multiple intersections, pedestrian detection, emergency vehicle preemption, and sophisticated optimization algorithms. The THRESHOLD_FOR_SWITCH and TIME_STEP would be configurable parameters crucial for fine-tuning performance.

Why Hands-On Practice is Non-Negotiable

Understanding the concepts is one thing; making a system like this work in a dynamic environment is another. The real challenge lies in:

Parameter Tuning: What's the optimal THRESHOLD_FOR_SWITCH? How do min_green_time and max_green_time interact across multiple intersections?
Edge Cases: What happens during peak hours, during an accident, or when sensors fail?
Scalability: How do you extend this logic from one intersection to an entire city?
Performance: Ensuring real-time decisions without introducing latency.

These are problems best solved by building, testing, and iterating. Reading about algorithms is great, but getting your hands dirty with a simulated environment lets you see the immediate impact of your configuration choices. It's where you learn the nuances of balancing flow, preventing deadlocks, and optimizing for various metrics.

Ready to Build Smarter Cities?

Configuring smart traffic systems is a fantastic way to apply your development skills to a tangible, impactful problem. It combines elements of data processing, algorithms, and real-time control. Instead of just theorizing, imagine deploying your own adaptive traffic logic and seeing the results unfold.

Practice this concept interactively on CodeCityApp — free trial at codecityapp.com

Originally published on CodeCityApp

Your pipeline was green for weeks. It shipped nothing.

Mike Clarke — Tue, 11 Aug 2026 14:00:05 +0000

There is a category of production failure that monitoring tools are almost designed to miss. The system runs. The pings arrive. Every dashboard stays green. And somewhere behind that green, nothing is happening.

We hit this with ARIA, the autonomous system we run at Elevare Digital. A pipeline had been silent for weeks. Not crashing — silent. The health checks came in on schedule. The function executed. And the work it existed to do was not getting done.

Key Takeaways

Liveness (did it run?) and function (did it accomplish anything?) are different properties. Most health checks only measure one.
A cron that reschedules, retries, or re-checks the same item will emit healthy pings indefinitely while producing zero output.
The fix is to make your health signal carry a payload: items processed, rows moved, work done.
Alert on absence of output over a window, not just on errors.
A green heartbeat on a pipeline that produces nothing is a failure wearing a healthy costume.

What we were checking vs. what we needed to check

The health check looked like this conceptually:

// What we had — liveness only
async function runPipeline() {
  await doWork(); // might do nothing
  await recordHealth({ status: 'ok', timestamp: new Date() });
}

The function ran. It called doWork(). It recorded status: ok. Monitoring saw the ping. Everything looked fine.

The problem: doWork() had silently reduced itself to re-checking one item it had already processed. It found nothing new, did nothing, and returned without error. The health signal had no idea. It recorded that the function executed — which was true — and implied from that the pipeline was functioning — which was not.

This distinction sounds obvious written out. It is easy to miss in practice because the failure mode produces no errors, no exceptions, no timeouts. It produces only silence, and your monitoring is not listening for silence.

The mechanism in plain terms

Cron fires. Function wakes up. Function checks for work. No new work is found (or the same old item keeps surfacing and getting skipped). Function exits cleanly. Health ping is recorded.

Repeat. Every interval. For weeks.

From the outside: healthy system.
From the inside: a poster that clocks in, sits down, does nothing, clocks out, and files a timesheet marked "completed."

The fix: make the health signal carry evidence of work

We changed the health record to include output metrics. Not just "did it run" but "what did it produce."

// What we changed to — function-level health
async function runPipeline() {
  const result = await doWork();

  await recordHealth({
    status: 'ok',
    timestamp: new Date(),
    items_processed: result.count, // the actual payload
  });
}

Then we added a check that looks at recent health records and alerts when a supposedly-active pipeline has emitted zero output over a window:

-- Supabase: find active pipelines that reported no work over the last N intervals
SELECT
  pipeline_name,
  COUNT(*) AS runs,
  SUM(items_processed) AS total_output,
  MAX(recorded_at) AS last_run
FROM pipeline_health
WHERE recorded_at > now() - interval '7 days'
GROUP BY pipeline_name
HAVING SUM(items_processed) = 0
ORDER BY last_run DESC;

This query has no interesting results on a healthy system. When it returns rows, a pipeline ran repeatedly and moved nothing — and that is worth an alert regardless of what the status field says.

Why this failure mode is common

Most health check patterns are borrowed from web services, where liveness and function are closely coupled. If your API endpoint returns 200, it almost certainly did the thing it exists to do. The request-response cycle forces the work to happen before the response is emitted.

Background pipelines are different. The work is decoupled from the signal. The function can complete — cleanly, successfully — and still have accomplished nothing. The health check fires after execution regardless of output.

So when teams instrument a pipeline the same way they instrument an endpoint, they end up measuring the wrong thing.

What to add to any pipeline health check

Three fields that matter more than status: ok:

interface PipelineHealthRecord {
  pipeline_name: string;
  recorded_at: string;
  status: 'ok' | 'error';

  // These are the fields that actually tell you something
  items_processed: number; // work done this run
  items_available: number | null; // work seen (optional but useful)
  error_detail: string | null;
}

With items_available you can distinguish between two very different situations:

Available = 0, processed = 0: queue is empty, pipeline is idle. Probably fine.
Available > 0, processed = 0: work exists, pipeline is not touching it. Not fine.

The second case is what we had. The pipeline could see work (or thought it could), entered its processing loop, and exited without moving anything. Status: ok the whole time.

The alert logic

Once the health records carry real output data, the alert becomes straightforward:

async function checkPipelineOutput(pipelineName: string) {
  const { data } = await supabase
    .from('pipeline_health')
    .select('items_processed, recorded_at')
    .eq('pipeline_name', pipelineName)
    .gte('recorded_at', new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString())
    .order('recorded_at', { ascending: false });

  if (!data || data.length === 0) return; // no runs at all — separate alert

  const totalOutput = data.reduce((sum, row) => sum + (row.items_processed ?? 0), 0);
  const runCount = data.length;

  if (runCount > 3 && totalOutput === 0) {
    await sendAlert({
      pipeline: pipelineName,
      message: `Ran ${runCount} times in the last 7 days. Produced zero output.`,
      severity: 'high',
    });
  }
}

The threshold (runCount > 3) is tunable. The point is that multiple runs with zero output is the signal. A single zero-output run might be a quiet period. Several in a row is the pipeline telling you something is wrong, if you are listening.

The honest lesson

We were not measuring the wrong thing by accident. We followed a normal health check pattern and it was simply insufficient for this class of job. The pattern works fine for services. It does not work for pipelines.

Log the absence of work as loudly as the presence of errors. Zero output on a pipeline that should be producing is not a quiet success. It is an invisible failure, and the only difference between that and a noisy crash is that the noisy crash gets fixed.

— Mike Clarke, founder of Elevare Digital.

The cleanup code that ate every code block in our published articles

Mike Clarke — Tue, 04 Aug 2026 14:00:21 +0000

Liquid syntax error: Variable '{{% raw %}' was not properly terminated with regexp: /\}\}/

Smart Traffic Systems: Configuring Flow for a Smarter City

Mike Clarke — Wed, 29 Jul 2026 06:00:20 +0000

Smart Traffic Systems: Configuring Flow for a Smarter City

Ever found yourself stuck in a gridlocked intersection, wondering why the lights aren't cooperating? Or perhaps you've mused about the sheer inefficiency of fixed-timer traffic signals in a dynamic urban landscape. As developers, these aren't just annoyances; they're ripe problems begging for intelligent solutions. And that's where smart traffic systems come in.

The Problem: Static Systems vs. Dynamic Reality

Traditional traffic light systems operate on pre-programmed timings. They don't care if an ambulance needs to pass, if a bus is running behind schedule, or if one lane is bumper-to-bumper while another is empty. This static approach leads to congestion, increased travel times, higher fuel consumption, and crucially, frustrated citizens. We can do better.

The Concept: Dynamic, Data-Driven Control

How to configure a smart traffic system? At its core, it's about shifting from reactive, static timing to proactive, data-driven optimization. A smart system continuously gathers data from various sources: loop detectors, cameras (for vehicle count and classification), GPS data from connected vehicles, even weather sensors. This data feeds into an intelligent agent, often leveraging AI/ML algorithms, to make real-time decisions about traffic light signalization, lane usage, pedestrian crossings, and even suggesting alternative routes.

Think of it as a central brain that constantly analyzes the pulse of the city's arteries and adjusts flow accordingly. The goal is to minimize overall travel time, reduce congestion, prioritize emergency vehicles, and optimize public transport efficiency. It's a complex optimization problem, often involving multi-agent systems and reinforcement learning.

A Glimpse Under the Hood (Pseudocode):

Let's imagine a simplified scenario for a single intersection. Our smart system needs to decide which phase (e.g., North-South green, East-West red) to activate and for how long.

// Initialize system components
TrafficLightController = new Controller()
SensorDataStream = new DataStreamService()
OptimalPhaseSelector = new MLModel()

// Main Loop - runs continuously
LOOP:
    // 1. Gather Real-time Data
    currentTrafficData = SensorDataStream.getLiveTrafficData(intersectionID)
    // currentTrafficData might include:
    //    - VehicleCountsPerLane
    //    - AverageWaitingTimesPerLane
    //    - PresenceOfEmergencyVehicles
    //    - PedestrianCrossingRequests

    // 2. Process Data and Determine Optimal Phase
    optimalPhaseResult = OptimalPhaseSelector.predictOptimalPhase(
        currentTrafficData,
        historicalTrafficPatterns,
        currentWeatherConditions
    )
    // optimalPhaseResult might contain:
    //    - recommendedPhase (e.g., 'NS_GREEN')
    //    - recommendedDuration (e.g., 45 seconds)
    //    - priorityFlags (e.g., 'EmergencyVehiclePresent')

    // 3. Command Traffic Lights
    IF optimalPhaseResult.priorityFlags.contains('EmergencyVehiclePresent'):
        TrafficLightController.triggerEmergencyPhase(optimalPhaseResult.recommendedPhase)
    ELSE:
        TrafficLightController.setPhase(optimalPhaseResult.recommendedPhase, optimalPhaseResult.recommendedDuration)

    // 4. Log and Monitor (for debugging and retraining)
    Log.event("Phase changed to " + optimalPhaseResult.recommendedPhase + " for " + optimalPhaseResult.recommendedDuration)
    Monitor.displayCurrentTrafficFlow()

    WAIT for short interval // Re-evaluate every few seconds
END LOOP

// --- Additional functions for OptimalPhaseSelector (simplified) ---

FUNCTION predictOptimalPhase(data, history, weather):
    // Example logic (highly simplified):
    IF data.EmergencyVehicles > 0:
        RETURN {recommendedPhase: 'ClearPathForEmergency', recommendedDuration: 10, priorityFlags: ['EmergencyVehiclePresent']}

    ELSE IF data.LaneTraffic['NorthBound'] > data.LaneTraffic['EastBound'] * 2 AND data.WaitingTimes['NorthBound'] > 60:
        RETURN {recommendedPhase: 'NS_GREEN', recommendedDuration: 60}

    ELSE IF data.PedestrianRequests['EastCross'] AND data.SafeToCross:
        RETURN {recommendedPhase: 'EW_PED_GREEN', recommendedDuration: 20}

    ELSE:
        // Fallback to a default or historical pattern if no strong signal
        RETURN {recommendedPhase: history.getDefaultPhaseForTimeOfDay(), recommendedDuration: 30}
END FUNCTION

This pseudocode barely scratches the surface. A real-world system would involve complex state machines, robust fault tolerance, distributed sensing, and sophisticated machine learning models trained on vast datasets. The OptimalPhaseSelector would likely be a black box of intricate algorithms deciding based on predicted future states, not just current ones.

Why Practice Matters in This Domain

Configuring a smart traffic system isn't just about writing code; it's about understanding complex systems, optimizing for multiple conflicting objectives, and handling real-time data under pressure. There are countless edge cases, from sensor failures to unexpected traffic surges. Practicing these concepts – building simplified models, simulating various scenarios, and tweaking parameters – is crucial for developing the intuition needed to build robust, life-changing solutions.

It's one thing to read about Reinforcement Learning; it's another to apply it to make a simulated city's traffic flow smoother. These are problems where your algorithms have a direct, tangible impact.

Practice this concept interactively on CodeCityApp — free trial at codecityapp.com

Originally published on CodeCityApp

The upsert said it worked. It wrote zero rows. Every single run.

Mike Clarke — Tue, 28 Jul 2026 14:00:04 +0000

Your scanner runs. It fetches data. It loops through rows, calls upsert, increments a success counter. It logs ✓ 42 rows processed. You check the table. Empty.

That ran every day for a while before we caught it.

Key Takeaways

ON CONFLICT (col) will not use a partial unique index (WHERE col IS NOT NULL) as the conflict arbiter. Postgres requires the predicate to be restated in the statement itself.
PostgREST's upsert path can't restate that predicate. Every row throws a quiet error.
A loop that only increments on success will report a perfectly healthy run that wrote absolutely nothing.
Fix: replace the partial index with a plain, unconditional unique index.

The setup

At Elevare Digital, ARIA runs data ingestion pipelines that pull from external sources and upsert into Postgres via Supabase. Standard stuff. One scanner's job was to fetch records and land them in a table, using a unique column as the conflict target so re-runs were idempotent.

The index on that column had been created like this, probably by someone being careful about NULLs:

CREATE UNIQUE INDEX records_external_id_idx
  ON records (external_id)
  WHERE external_id IS NOT NULL;

Reasonable-looking. Partial indexes are useful. This one quietly broke everything.

What Postgres actually requires

When you write:

INSERT INTO records (external_id, payload)
VALUES ('abc-123', '{...}')
ON CONFLICT (external_id) DO UPDATE
  SET payload = EXCLUDED.payload;

Postgres needs to identify which unique constraint or index to use as the arbiter. For a full unique index, ON CONFLICT (external_id) is enough — Postgres finds it.

For a partial unique index, Postgres requires the conflict target to include the index predicate:

INSERT INTO records (external_id, payload)
VALUES ('abc-123', '{...}')
ON CONFLICT (external_id) WHERE external_id IS NOT NULL  -- restate the predicate
DO UPDATE
  SET payload = EXCLUDED.payload;

Without that WHERE clause, Postgres cannot match the partial index. It doesn't fall back. It throws an error:

ERROR: there is no unique or exclusion constraint matching the ON CONFLICT specification

You can verify this yourself in a few lines:

-- Create a table with a partial unique index
CREATE TABLE demo (id serial, external_id text, payload text);
CREATE UNIQUE INDEX demo_ext_id_partial ON demo (external_id) WHERE external_id IS NOT NULL;

-- This fails — Postgres can't match the partial index
INSERT INTO demo (external_id, payload) VALUES ('x1', 'a')
ON CONFLICT (external_id) DO UPDATE SET payload = EXCLUDED.payload;
-- ERROR: there is no unique or exclusion constraint matching the ON CONFLICT specification

-- This works — predicate restated
INSERT INTO demo (external_id, payload) VALUES ('x1', 'a')
ON CONFLICT (external_id) WHERE external_id IS NOT NULL
DO UPDATE SET payload = EXCLUDED.payload;
-- INSERT 0 1

Why PostgREST couldn't restate the predicate

ARIA calls Supabase's upsert via PostgREST. The request looks something like:

const { error } = await supabase
  .from('records')
  .upsert(rows, { onConflict: 'external_id' });

PostgREST translates onConflict: 'external_id' into:

ON CONFLICT (external_id) DO UPDATE ...

There's no interface in PostgREST's upsert path to append an arbitrary WHERE predicate to the conflict target. So every row-level upsert hit the same error. Every row.

Why the loop reported success

The ingestion loop looked roughly like this:

let successCount = 0;

for (const row of fetchedRows) {
  const { error } = await supabase
    .from('records')
    .upsert(row, { onConflict: 'external_id' });

  if (!error) {
    successCount++;
    // error case: nothing. no log, no throw, no increment.
  }
}

console.log(`✓ ${successCount} rows processed`);

When error was non-null, the loop just... continued. No log. No counter. The success counter never moved, but fetchedRows.length rows later, it logged a number that looked fine because the fetch itself succeeded.

Actually — it logged 0. But nobody was watching for zero. Zero looks like "nothing to sync today."

A counter that only moves on success will always look plausible. You need to also track failures:

let successCount = 0;
let errorCount = 0;

for (const row of fetchedRows) {
  const { error } = await supabase
    .from('records')
    .upsert(row, { onConflict: 'external_id' });

  if (error) {
    errorCount++;
    console.error('upsert failed:', error.message, row.external_id);
  } else {
    successCount++;
  }
}

console.log(`processed: ${successCount} ok, ${errorCount} failed of ${fetchedRows.length} fetched`);

if (errorCount > 0) {
  throw new Error(`ingestion completed with ${errorCount} errors`);
}

Now a run that writes nothing will at least be loud about it.

The fix

Drop the partial index. Create a plain one.

DROP INDEX records_external_id_idx;

CREATE UNIQUE INDEX records_external_id_idx
  ON records (external_id);

If NULLs are genuinely a concern, handle them at the application layer or with a NOT NULL constraint on the column. A partial index to "exclude NULLs" is not worth the silent failure mode when you need conflict arbitration.

After the index swap, the PostgREST upsert matched correctly and rows started landing.

The honest lesson

Postgres did nothing wrong here. The docs describe this requirement. The error message is clear. The problem was that the error was being swallowed and nothing downstream cared that zero rows were written.

Two independent things had to both be true for this to stay hidden:

A partial index being used as an ON CONFLICT target without the predicate
A loop that treated errors as a no-op

Either one alone might have surfaced faster. Together, they produced a system that appeared healthy and did nothing.

When you write an ingestion loop, the number that matters isn't "how many did I try" or "how many succeeded." It's the ratio. And if errors are silent, you'll never compute it.

— Mike Clarke, founder of Elevare Digital.

The leads were in the table. The automation never saw them.

Mike Clarke — Fri, 24 Jul 2026 14:00:12 +0000

There were two groups of leads sitting in contacted state. One group was getting follow-up emails, call tasks, the whole sequence. The other group was getting nothing — indefinitely.

Same status. Same table. Different outcomes. No errors anywhere.

Key Takeaways

A "dead population path" is when one write route into a table skips a step that downstream automation assumes happened.
Bulk imports are the most common source of this. They write directly to the final state, skipping every intermediate code path.
The fix is not patching the import. It's a trigger that enforces enrollment regardless of how a row arrives.
For every table your automation reads: list every way rows enter it, then verify each path runs the prerequisites downstream depends on.

What was actually happening

The CRM pipeline in ARIA works like this: a lead gets contacted, the first-contact handler fires, it enrolls the lead in the follow-up sequence. That enrollment step lived exclusively inside the first-contact code path.

User action / API call
  → first-contact handler
      → write lead to `contacted` state
      → enroll in follow-up sequence  ← this is the step

Someone ran a bulk import. It wrote records straight to contacted. No handler. No enrollment.

Bulk import
  → write lead to `contacted` state
                                      ← nothing

The downstream automation that sends follow-ups reads the leads table and looks for enrolled leads in contacted state. The imported leads were in the right table, in the right state, but they were never enrolled. The automation skipped them every single cycle — correctly, by its own logic.

No error. No warning. Just silence.

The gap never closed because there was no reconciliation job. Nothing periodically asked "are there contacted leads that aren't in the sequence?" The imported population just sat there.

Why this is easy to miss

The table looked fine. The leads looked fine. The automation looked fine.

The bug was architectural: there were two write routes into one table, and only one of them ran the setup step the other parts of the system depended on. The system had no way to detect the discrepancy because it never compared "who should be enrolled" against "who is enrolled." It just processed whoever was already enrolled.

This is what I'd call a dead population path. The rows exist. The automation is running. The rows are just invisible to it.

Bulk imports create this constantly because they're designed to skip your application layer — that's literally their value proposition. The problem is your application layer is often where side effects live.

The fix: enforce enrollment at the database layer

The only reliable fix is moving the enrollment check to a place that runs regardless of how the row was written. Postgres triggers do this.

-- The trigger function
CREATE OR REPLACE FUNCTION enroll_contacted_lead()
RETURNS TRIGGER AS $$
BEGIN
  -- Only act on rows entering or already in 'contacted' state
  IF NEW.status = 'contacted' THEN
    -- Check whether this lead qualifies for enrollment
    IF NEW.assigned_to IS NOT NULL AND NEW.email IS NOT NULL THEN
      -- Enroll if not already enrolled
      INSERT INTO follow_up_enrollments (lead_id, enrolled_at, sequence_id)
      VALUES (NEW.id, now(), NEW.sequence_id)
      ON CONFLICT (lead_id) DO NOTHING;
    ELSE
      -- Log why it was skipped so you can find these later
      INSERT INTO enrollment_skipped_log (lead_id, reason, skipped_at)
      VALUES (
        NEW.id,
        CASE
          WHEN NEW.assigned_to IS NULL THEN 'no_assignee'
          WHEN NEW.email IS NULL THEN 'no_email'
          ELSE 'unknown'
        END,
        now()
      )
      ON CONFLICT (lead_id) DO NOTHING;
    END IF;
  END IF;

  RETURN NEW;
END;
$$ LANGUAGE plpgsql;

-- Attach it to both INSERT and UPDATE
-- so it catches bulk imports (INSERT) and status changes (UPDATE) alike
CREATE TRIGGER trg_enroll_contacted_lead
AFTER INSERT OR UPDATE OF status ON leads
FOR EACH ROW
EXECUTE FUNCTION enroll_contacted_lead();

A few things worth noting about this implementation:

ON CONFLICT DO NOTHING on the enrollment insert means existing correctly-enrolled leads are untouched. Safe to run on a table that already has good data.

The skip log is not optional. If a lead doesn't qualify, you want to know why. Without it, you're back to silent failures. The log gives you a query you can run to find every lead that got skipped and the reason.

AFTER INSERT OR UPDATE OF status covers both paths. The bulk import fires INSERT. A status change through the application fires UPDATE. Both paths now run the same enrollment logic.

In Supabase, you apply this in the SQL editor or through a migration file. No special Supabase API needed — it's just Postgres.

Backfilling the existing gap

The trigger handles new rows. But the affected leads already in the table needed a one-time backfill.

-- Enroll any existing contacted leads that slipped through
INSERT INTO follow_up_enrollments (lead_id, enrolled_at, sequence_id)
SELECT
  l.id,
  now(),
  l.sequence_id
FROM leads l
LEFT JOIN follow_up_enrollments fe ON fe.lead_id = l.id
WHERE
  l.status = 'contacted'
  AND fe.lead_id IS NULL           -- not already enrolled
  AND l.assigned_to IS NOT NULL    -- qualifies
  AND l.email IS NOT NULL;         -- qualifies

Run this once after deploying the trigger. Then the trigger maintains the invariant going forward.

The question to ask about every table your automation reads

What are all the ways rows get into this table, and does each one run the steps downstream assumes happened?

For most tables the answer is one or two paths and they're all through your application code. Fine.

But the moment you add a bulk import, a migration script, a database-level upsert from an external tool, or a direct admin write — you've added a path that bypasses your application layer. Any side effects that lived there are now missing for those rows.

The fix isn't to never import. It's to stop trusting that write path determines setup steps. Push the invariants down to the database, where they apply to every write regardless of origin.

Honest lesson

This was a silent failure that looked like working software. The table had data. The automation was running. The logs showed no errors. The only way to notice was to ask why two groups with the same status were having different outcomes — and actually go find the answer.

AI systems like ARIA that run autonomously are more exposed to this class of bug, not less. There's no human checking each lead. The automation either processes them or it doesn't, and if it doesn't, you need something in the system that catches the gap. A trigger logging skipped records is a simple form of that. A reconciliation job that periodically diffs expected vs actual enrollment is a stronger one.

Both beat finding out months later when a customer asks why no one followed up.

— Mike Clarke, founder of Elevare Digital.

The table looked general-purpose. The schema disagreed.

Mike Clarke — Tue, 21 Jul 2026 14:00:09 +0000

A CHECK constraint is documentation with teeth.

That's the whole lesson. But here's what it looks like when you learn it at runtime instead of at read-time.

Key Takeaways

A CHECK constraint encodes scope assumptions the column name never will
A constraint violation inside a trigger aborts the parent transaction — silently, from the caller's perspective
Before writing to a table you inherited, run \d tablename or query information_schema.check_constraints. Read what's there.
Gate on allowed values in code before the insert. Let the constraint be a backstop, not the first line of defense.
Skip-and-log beats throw-and-abort when the parent write is more important than the child record

What happened

We run ARIA, an autonomous CRM and nurture automation system at Elevare Digital. New contact records enroll into follow-up sequences automatically — no human queues the work.

At some point, new records stopped enrolling. The parent write (creating the contact) was aborting entirely. No sequence. No contact. No error surfaced to the caller in a useful way.

The culprit was a region column with a CHECK constraint that looked roughly like this:

ALTER TABLE enrollment_tracker
  ADD CONSTRAINT region_allowed
  CHECK (region IN ('north', 'south', 'east', 'west', 'central'));

The table had been built for one specific program covering five regions. Later, code started treating it as a general enrollment tracker and writing region values the constraint never anticipated. Postgres rejected the insert. Because that insert happened inside a trigger, the whole parent transaction rolled back.

The column was named region. Nothing in that name says "only these five values are valid." The constraint said it. Nobody read the constraint.

Why a trigger makes this worse

If you insert directly into a table and violate a CHECK, you get an error back immediately. Annoying, but contained.

When the insert is inside a trigger on a different table, the error propagates up and aborts the statement that fired the trigger. The caller sees their write fail. They may have no idea a trigger was involved, let alone which constraint fired inside it.

-- Trigger fires on INSERT to contacts
CREATE OR REPLACE FUNCTION enroll_contact()
RETURNS trigger AS $$
BEGIN
  -- This insert can blow up the parent INSERT INTO contacts
  INSERT INTO enrollment_tracker (contact_id, region, enrolled_at)
  VALUES (NEW.id, NEW.region, now());

  RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER trg_enroll
AFTER INSERT ON contacts
FOR EACH ROW EXECUTE FUNCTION enroll_contact();

Now do this:

INSERT INTO contacts (id, name, region)
VALUES (gen_random_uuid(), 'Acme Corp', 'southeast');
-- ERROR: new row for relation "enrollment_tracker" violates
-- check constraint "region_allowed"
-- DETAIL: Failing row contains (..., southeast, ...).
-- The contact was NOT created.

southeast is a perfectly valid business concept. The table just never knew about it.

The fix: gate before you insert

Once we understood the constraint, the fix was straightforward. Check the allowed values in code (or in the trigger function itself) before attempting the insert. If the value isn't allowed, skip the enrollment record and log it. The parent write completes.

CREATE OR REPLACE FUNCTION enroll_contact()
RETURNS trigger AS $$
DECLARE
  allowed_regions TEXT[] := ARRAY['north', 'south', 'east', 'west', 'central'];
BEGIN
  IF NEW.region = ANY(allowed_regions) THEN
    INSERT INTO enrollment_tracker (contact_id, region, enrolled_at)
    VALUES (NEW.id, NEW.region, now());
  ELSE
    -- Log it; don't abort the parent write
    INSERT INTO enrollment_skipped (contact_id, region, skipped_at, reason)
    VALUES (NEW.id, NEW.region, now(), 'region not in enrollment_tracker allowed list');
  END IF;

  RETURN NEW;
END;
$$ LANGUAGE plpgsql;

Alternately, you can query the constraint definition directly rather than hardcoding the list — which is useful if the allowed values might expand:

-- Pull allowed values from the constraint definition at runtime
-- (useful for visibility; hardcoding is fine if values are stable)
SELECT consrc
FROM pg_constraint
WHERE conname = 'region_allowed'
  AND conrelid = 'enrollment_tracker'::regclass;

Returns something like (region = ANY (ARRAY['north'::text, 'south'::text, ...])). Not the cleanest parse, but it tells you exactly what the schema intended.

How to read the constraints you inherited

Before writing to any table you didn't build:

-- psql shortcut
\d enrollment_tracker

-- Or query directly
SELECT
  tc.constraint_name,
  tc.constraint_type,
  cc.check_clause
FROM information_schema.table_constraints tc
LEFT JOIN information_schema.check_constraints cc
  ON tc.constraint_name = cc.constraint_name
WHERE tc.table_name = 'enrollment_tracker';

Constraints you'll find this way:

CHECK — allowed values, ranges, cross-column rules
UNIQUE — uniqueness you may not have assumed
NOT NULL — columns the schema considers required
FOREIGN KEY — referential dependencies

None of this is hidden. It's just rarely read.

The actual lesson

The table name was enrollment_tracker. That sounds general. It wasn't — it was built for a specific program with five regions, and the CHECK constraint was the only place that scope was written down.

When later code treated it as a general tracker, it imported an assumption it never knew was there. The schema surfaced that assumption at write time, inside a trigger, in a way that took down the parent record.

Schema constraints are the closest thing to binding documentation that most databases have. They don't drift. They don't get outdated and left in a wiki. They're enforced.

Read them before you write. Not after.

— Mike Clarke, founder of Elevare Digital.

Your AI agent checked its queue, found nothing, and went back to sleep. The queue was full.

Mike Clarke — Fri, 17 Jul 2026 14:00:09 +0000

Postgres Row-Level Security doesn't raise an error when it blocks you. It returns zero rows. Your query succeeds. Your agent sees an empty queue. Your agent idles. Your jobs pile up.

This is what happened to ARIA, our autonomous AI system at Elevare Digital.

Key Takeaways

Postgres RLS silently filters rows on SELECT — a blocked read and a genuinely empty table look identical to the caller
An orchestrator that reads its own queue gets no exception, no warning, no non-200 status code when RLS blocks it
A healthy heartbeat on an idle agent tells you nothing about whether the idle is real
The fix: add a canary count that verifies you can read, not just that you did read
Treat an empty read as a question, not an answer

What the agent saw

The orchestrator polls a work queue table. Normal operation:

Query for pending jobs
If results → process them
If empty → log idle heartbeat, sleep

The logs showed healthy idle heartbeats. Monitoring showed the agent alive and polling. From the outside, everything looked fine.

Jobs were not being processed.

What actually happened

Someone added a Row-Level Security policy to the queue table, scoped to auth.uid(). Correct for user-facing reads. But the orchestrator connects under the service role — and no service-role bypass was added to the policy.

Here's the policy as it was written:

-- Added for user-facing queue visibility
CREATE POLICY "users_see_own_jobs"
  ON work_queue
  FOR SELECT
  USING (auth.uid() = user_id);

And RLS was enabled on the table:

ALTER TABLE work_queue ENABLE ROW LEVEL SECURITY;

No bypass for the service role. No FOR ALL escape. The orchestrator's SELECT now matched zero rows — because RLS filtered every row out before returning results.

Postgres does not raise. It does not warn. The query completes with status 200 and an empty array.

// Orchestrator poll — looks completely normal
const { data: jobs, error } = await supabase
  .from('work_queue')
  .select('*')
  .eq('status', 'pending');

// error is null. jobs is []. Agent concludes: nothing to do.
if (!jobs || jobs.length === 0) {
  await recordIdleHeartbeat();
  return;
}

The error is null. The jobs array is empty. The agent's logic is correct for the data it received. The data it received was wrong in a way that produced no signal.

Why this is hard to catch

If RLS blocks a write, you often get an error — the row you tried to insert violates a policy, or returns nothing when you expected a rowcount. Writes are easier to notice.

SELECT under RLS is different. The design intent is that users should not be able to distinguish "this row doesn't exist" from "this row exists but you can't see it." That's a security feature. It's also exactly the wrong behavior for an orchestrator that needs to know the difference between "queue is empty" and "I am blind."

The service role in Supabase bypasses RLS by default — but only if you're using the service-role key on the client. If your edge function or backend is using the anon key, or if it's operating in a context where auth.uid() resolves to null, RLS applies and silently filters.

-- This is what the orchestrator needed, but wasn't there
CREATE POLICY "service_role_bypass"
  ON work_queue
  FOR ALL
  USING (auth.role() = 'service_role');

-- Or, simpler: grant the service role explicit bypass at the table level
ALTER TABLE work_queue FORCE ROW LEVEL SECURITY; -- applies to all
-- and then in your Supabase client: use the service-role key, which bypasses RLS automatically

The actual bypass mechanism in Supabase is that the service-role JWT includes "role": "service_role", and Supabase's Postgres config grants that role BYPASSRLS. If your client is initialized with the service-role key, you're fine. If it's not, RLS applies — no error, just silence.

The fix: a canary count

The real repair has two parts: fix the RLS policy, and add a check that will catch this failure mode again.

Part 1 — Fix the policy:

-- Preserve user-facing policy
CREATE POLICY "users_see_own_jobs"
  ON work_queue
  FOR SELECT
  USING (auth.uid() = user_id);

-- Add explicit service-role access
-- (Or: initialize your orchestrator client with the service-role key,
--  which bypasses RLS automatically via BYPASSRLS grant)
CREATE POLICY "orchestrator_full_access"
  ON work_queue
  FOR ALL
  USING (auth.role() = 'service_role')
  WITH CHECK (auth.role() = 'service_role');

Part 2 — The canary check:

The orchestrator now runs a canary query before trusting an empty result. The canary queries a row it knows exists — a sentinel row inserted specifically for this purpose, or a count from an unrestricted table the orchestrator owns.

async function pollQueue() {
  const { data: jobs, error: queueError } = await supabase
    .from('work_queue')
    .select('*')
    .eq('status', 'pending');

  if (queueError) {
    await alertOpsChannel('queue_poll_error', queueError);
    return;
  }

  // Jobs came back — process normally
  if (jobs && jobs.length > 0) {
    await processJobs(jobs);
    return;
  }

  // Empty result — but is it genuinely empty, or are we blind?
  const canaryOk = await verifyReadAccess();
  if (!canaryOk) {
    // This is the case we were missing before
    await alertOpsChannel('queue_read_access_lost', {
      message: 'Orchestrator received empty queue result but canary check failed. Possible RLS or permission regression.',
    });
    return; // Do NOT record idle heartbeat — we don't know the real state
  }

  // Canary passed — empty really means empty
  await recordIdleHeartbeat();
}

async function verifyReadAccess(): Promise<boolean> {
  // Query a sentinel row that always exists in a known state
  // This could be a dedicated canary table, or a system-health row
  const { data, error } = await supabase
    .from('orchestrator_canary')
    .select('id')
    .eq('id', 'heartbeat-sentinel')
    .single();

  if (error || !data) {
    // We expected exactly one row. Getting nothing means access is broken.
    return false;
  }

  return true;
}

The canary table is simple:

CREATE TABLE orchestrator_canary (
  id TEXT PRIMARY KEY
);

INSERT INTO orchestrator_canary (id) VALUES ('heartbeat-sentinel');

-- No RLS on this table — it exists only so the orchestrator can verify it can read
-- If you want RLS: add only a service-role policy, nothing user-facing

Now the orchestrator has three states instead of two:

Jobs found → process
No jobs, canary ok → genuinely idle
No jobs, canary failed → alert, do not idle

The third state was always real. We just had no way to observe it.

The deeper issue with autonomous agents and silent failures

Human-in-the-loop systems fail loudly. A user tries to load their queue, sees nothing, and files a ticket. An autonomous agent has no user. It reads, decides, acts. If the read is silently wrong, the decision is wrong, and nothing complains.

This failure mode matters more as systems get more autonomous. ARIA processes queued work without someone watching every poll cycle. The assumption baked into the polling loop was: an empty read means there is nothing to do. That assumption held until it didn't, and the system had no way to question it.

The fix is to make the orchestrator skeptical of its own empty results. Not paranoid — just skeptical enough to verify the precondition that makes "empty" meaningful.

What to check in your own system

If you're running any kind of queue worker against Postgres or Supabase:

Check which key your worker is using. Supabase service-role key bypasses RLS. Anon key does not. Confirm which one is in your edge function or backend environment.
List your RLS policies and check for missing bypasses. SELECT * FROM pg_policies WHERE tablename = 'your_queue_table';
Look at your idle heartbeats. If idle logging increased around the time you last modified permissions or added RLS, that's worth investigating.
Add a canary. Takes an hour. Catches this entire class of problem permanently.

An empty queue result is not evidence of an empty queue. It's evidence that the query ran. Those are different things, and in autonomous systems, the difference matters.

— Mike Clarke, founder of Elevare Digital.