DEV Community: Mike Clarke

How to Configure the Smart Traffic System: An Architectural Guide

Mike Clarke — Wed, 04 Nov 2026 06:00:24 +0000

Every developer thinks configuring a traffic controller is trivial until they actually have to design one. On paper, it is just cycling lights between red, yellow, and green. In reality, you are balancing concurrent telemetry streams, pedestrian interrupts, emergency vehicle overrides, and strict fail-safe guarantees.

Static timer loops fail the moment a stadium lets out or an ambulance hits the grid. If you are trying to understand how to configure the smart traffic system, you need to treat intersections as dynamic, distributed state machines rather than simple cron jobs. Here is how to approach the architecture.

The Core Concept: Decoupled Telemetry and Deterministic States

A resilient smart traffic system splits into three decoupled layers:

Ingestion Layer: Consumes sensor inputs (loop detectors, camera object counts, pedestrian buttons, V2X emergency beacons).
Rules & Scheduling Engine: Calculates demand scores based on queue lengths, wait times, and priority classes.
Actuator / Safety Layer: A strict Finite State Machine (FSM) that enforces legal phase transitions (e.g., requiring clearing intervals between conflicting green lights).

To configure the system effectively, your scheduler should never mutate signal states directly. Instead, the scheduler emits phase requests, and the safety controller validates them against hard constraints like minimum green time and all-red clearing intervals.

Orchestration Logic (Pseudocode)

Here is a high-level representation of how to process sensor telemetry and score conflicting traffic phases before requesting an FSM state change:

structure IntersectionConfig:
    min_green_time = 10
    max_green_time = 60
    yellow_duration = 4
    all_red_clear = 2

function evaluateTrafficPhase(current_phase, sensor_stream):
    // 1. Check for critical overrides (Emergency, Transit)
    if sensor_stream.has_emergency_vehicle():
        return build_emergency_route(sensor_stream.emergency_lane)

    // 2. Aggregate demand metrics across active lanes
    phase_scores = {}
    for phase in available_phases:
        queue_depth = sensor_stream.get_vehicle_count(phase.lanes)
        wait_latency = sensor_stream.get_max_wait_seconds(phase.lanes)

        // Weight wait time to prevent lane starvation
        phase_scores[phase] = (queue_depth * 1.2) + (wait_latency * 0.8)

    target_phase = get_highest_priority(phase_scores)

    // 3. Enforce timing constraints before issuing transition
    if current_phase.elapsed_time < IntersectionConfig.min_green_time:
        return KEEP_CURRENT_PHASE

    if target_phase != current_phase:
        return schedule_transition(current_phase, target_phase, IntersectionConfig)

    return EXTEND_PHASE

Notice how the scoring function incorporates both queue volume and latency. Without accounting for wait latency, a low-density cross street might never get a green light during peak rush hour on an arterial road.

Why Hands-On Practice Matters

Writing pseudocode for an algorithm like this is the easy part. The real complexity surfaces when things break in production:

Race conditions: What happens if an emergency vehicle preempts a phase right as the pedestrian countdown hits zero?
Sensor degradation: If a road sensor fails open and reports zero vehicles, does your configuration starve that lane indefinitely?
Distributed coordination: Managing a single intersection is manageable; synchronizing a corridor of six intersections without causing gridlock requires green-wave timing and backpressure handling.

Reading system design posts gives you the high-level vocabulary, but you only master concurrency patterns, state management, and edge-case handling by getting your hands dirty with real scenarios.

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

Originally published on CodeCityApp

How to Configure the Smart Traffic System: An Architecture & Implementation Guide

Mike Clarke — Wed, 28 Oct 2026 06:00:24 +0000

Static timers don't cut it anymore. If you've ever sat at an empty four-way intersection watching an empty cross-street hold a green light for 45 seconds, you know why legacy traffic systems fail. They treat variable human behavior like a deterministic cron job.

Building dynamic city infrastructure demands modern software patterns. When you sit down to tackle how to configure the smart traffic system, you aren't just toggling a few timing variables. You are designing an event-driven, distributed system capable of ingesting noisy edge telemetry, mitigating safety hazards via strict state machines, and dynamically recalculating green splits in real time.

Here is how to think about the architecture, how to structure the configuration, and how to tie it all together.

The Core Architecture: From Telemetry to Actuation

A resilient smart traffic system splits clean boundaries across three layers:

Sensor Ingestion (The Edge): Ingests events from inductive loops, thermal cameras, pedestrian buttons, and emergency vehicle optical/radio preemption transponders.
The Policy Engine (Arbitration): Determines phase priorities. It uses weighted queue algorithms (e.g., max-pressure control) to dynamically balance queue lengths against dwell times, preventing starvation.
The Safety State Machine (Actuator Layer): Enforces non-negotiable physical constraints. No matter what the optimization policy calculates, this layer guarantees yellow-clearance minimums, all-red safety buffers, and conflict-phase isolation (no dual greens on intersecting paths).

When configuring the system, you define the intersection topology, timing envelopes, and sensor-to-phase bindings.

Configuration & Logic Skeleton (Pseudocode)

Instead of hardcoding intervals, configure your intersection using an explicit schema that couples geometric phases with dynamic bounds:

// 1. Intersection Configuration Schema
Configuration IntersectionConfig {
    phases: [
        {
            id: "Phase_NorthSouth",
            minGreenSeconds: 10,
            maxGreenSeconds: 60,
            yellowDurationSeconds: 4,
            allRedSeconds: 2,
            conflictsWith: ["Phase_EastWest", "Phase_Pedestrian_Crosswalk"],
            sensors: ["cam_north_01", "loop_south_02"]
        },
        {
            id: "Phase_EastWest",
            minGreenSeconds: 10,
            maxGreenSeconds: 45,
            yellowDurationSeconds: 4,
            allRedSeconds: 2,
            conflictsWith: ["Phase_NorthSouth"],
            sensors: ["cam_east_01", "cam_west_01"]
        }
    ],
    emergencyPreemptionEnabled: true
}

Next, the runtime controller evaluates sensor inputs against the active phase constraints:

// 2. High-Level Controller Loop
function evaluateTrafficCycle(intersectionState, sensorStream) {
    activePhase = intersectionState.getCurrentPhase()
    elapsedTime = intersectionState.getTimeInCurrentPhase()

    // Check for high-priority preemption first
    if (sensorStream.hasEmergencyVehicle()) {
        targetPhase = sensorStream.getEmergencyTargetPhase()
        return transitionSafely(activePhase, targetPhase)
    }

    // Respect minimum safe green times
    if (elapsedTime < activePhase.minGreenSeconds) {
        return maintainCurrentPhase(activePhase)
    }

    // Calculate demand across competing phases
    demandScores = calculatePhaseDemands(intersectionState.getInactivePhases(), sensorStream)
    highestDemandPhase = demandScores.getTopCandidate()

    // Transition if active phase exceeded max green OR competing demand exceeds threshold
    if (elapsedTime >= activePhase.maxGreenSeconds or demandScores.shouldYield(activePhase)) {
        return transitionSafely(activePhase, highestDemandPhase)
    }

    return maintainCurrentPhase(activePhase)
}

Notice that the optimization engine never directly switches lights. It proposes transitions to transitionSafely(), which walks through yellow and all-red clearance steps deterministically.

Why Practice Matters: The Edge Cases Will Break You

On paper, configuring an actuated traffic system seems straightforward: take inputs, apply weights, swap phases.

In reality, edge conditions introduce dangerous failure modes:

Sensor dropouts: What happens when an inductive loop fails open and registers infinite phantom cars?
Preemption races: An ambulance heading North arrives simultaneously with a fire engine heading West.
Starvation deadlocks: A high-volume arterial perpetually suppresses a low-volume side street, keeping cross-traffic trapped indefinitely.

You cannot test these failure paths safely on production hardware. Simulating concurrent sensor bursts, fail-safe defaults (like falling back to flashing red during system degradation), and state synchronization requires hands-on practice in an isolated environment.

Build and Test It Yourself

Theory gets you started, but writing the control logic and stress-testing it against asynchronous edge events is where real distributed systems engineering happens.

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

Originally published on CodeCityApp

How to Configure the Smart Traffic System: A Developer's Guide

Mike Clarke — Wed, 21 Oct 2026 06:00:26 +0000

Static timers for traffic intersections belong in the 1990s. If you've ever found yourself waiting at an empty crossroad at 2:00 AM while a red light counts down from 45 seconds, you know why dynamic traffic routing is a critical engineering problem.

Modern intersections require distributed event ingestion, state machines, and dynamic priority scheduling. When engineering teams ask how to configure the smart traffic system, they aren't looking for a basic hardware manual—they need to know how to structure the control loop, manage sensor telemetry, and safely handle edge cases like emergency vehicle preemption without deadlocking an entire sector.

Here is how to configure a reactive, resilient smart traffic control system from the ground up.

The Core Architecture: Three Decoupled Layers

To configure an effective smart traffic system, avoid tightly coupling sensor inputs directly to actuation outputs. Instead, organize the controller around three decoupled tiers:

Sensor Ingestion Layer: Ingests live telemetry from inductive road loops, camera-based object detection, and connected-vehicle beacon endpoints (e.g., MQTT or WebSockets).
Decision & Arbitration Engine: A finite state machine (FSM) that evaluates dynamic weights—combining queue depth, wait duration, and vehicle classification (e.g., priority for transit buses or sirens).
Actuation & Safety Layer: Validates proposed state transitions against hard safety constraints (minimum green times, mandatory yellow clearance, all-red intervals) before sending commands to physical controllers.

When configuring parameters, your configuration file should separate hard safety invariants from tunable heuristic weights.

Architectural Pseudocode: The Dynamic Decision Loop

Here is how the core control loop evaluates dynamic inputs to determine the next phase:

CONFIGURATION IntersectionConfig:
    MIN_GREEN_TIME = 10s
    MAX_GREEN_TIME = 60s
    YELLOW_CLEARANCE = 4s
    EMERGENCY_OVERRIDE_WEIGHT = 1000
    TRANSIT_PRIORITY_WEIGHT = 20

FUNCTION EvaluateNextPhase(intersectionState, sensorFeeds):
    // 1. Check safety constraint: Has active phase met minimum duration?
    IF intersectionState.activePhase.elapsedTime < MIN_GREEN_TIME:
        RETURN intersectionState.activePhase

    // 2. Score pending phases based on live metrics
    phaseScores = NEW Map()
    FOR EACH phase IN intersectionState.candidatePhases:
        densityScore = sensorFeeds.getVehicleCount(phase.laneGroup)
        waitTimePenalty = sensorFeeds.getOldestWaitingSeconds(phase.laneGroup) * 1.5
        priorityBoost = 0

        IF sensorFeeds.hasEmergencyVehicle(phase.laneGroup):
            priorityBoost += EMERGENCY_OVERRIDE_WEIGHT
        ELSE IF sensorFeeds.hasPublicTransit(phase.laneGroup):
            priorityBoost += TRANSIT_PRIORITY_WEIGHT

        phaseScores[phase.id] = densityScore + waitTimePenalty + priorityBoost

    // 3. Select phase with highest demand
    selectedPhase = phaseScores.getHighestScoringPhase()

    // 4. Trigger transition if demand shifts or max green reached
    IF selectedPhase != intersectionState.activePhase OR intersectionState.activePhase.elapsedTime >= MAX_GREEN_TIME:
        RETURN InitiateTransition(intersectionState.activePhase, selectedPhase, YELLOW_CLEARANCE)

    RETURN intersectionState.activePhase

In your deployment, this logic runs inside an isolated worker loop, isolated from volatile network I/O to guarantee real-time tick execution.

Why Hands-On Practice Matters

Designing traffic systems on a whiteboard looks deceptively simple. In production, concurrency breaks assumptions fast.

What happens when two ambulances approach conflicting lanes simultaneously? What happens when a camera feed drops out and sends stale zero-occupancy metrics? How does your system transition gracefully into a degraded failsafe state (like an all-way flashing yellow/red)?

Reading architectural docs gives you the theory, but you only master event-driven state machines and real-time scheduling by simulating traffic flows, injecting edge-case faults, and refactoring your controllers under load.

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

Originally published on CodeCityApp

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.