A Secure, Lightweight, and Low-Latency Edge–Cloud Architecture for Intelligent V2X Communication Systems ^†

Abstract

Next-generation Intelligent Transportation Systems (ITSs) require ultra-reliable, low-latency Vehicle-to-Everything (V2X) communication frameworks that support safety-critical vehicular services. Conventional centralized, monolithic architectures suffer from excessive transmission latency, limited scalability, and authentication overheads that are ill-suited to the highly dynamic and dense vehicular environment. This paper presents a secure and low-latency edge–cloud architecture for intelligent V2X communications based on a lightweight microservice-driven design paradigm. A formal latency-constrained model is presented to ensure that the end-to-end delay satisfies tight real-time constraints. The proposed framework is lightweight and includes HMAC-based authentication, nonce-based replay protection, timestamp validation, and short-lived encrypted session tokens in a stateless architecture using the Laravel framework deployed at the edge layer. Security validation is performed at edge gateways, and asynchronous SQLite-backed job queues support non-blocking telemetry processing and scalable service orchestration. Experimental evaluation shows that the edge-based deployment achieves a mean response time of 2.58 ms with small variance under repeated request conditions, while centralized processing exhibits significantly higher latency. The results demonstrate that secure authentication and telemetry exchange can be achieved without breaching strict latency requirements. The proposed solution creates a deployable, scalable, and security-aware foundation for next-generation V2X ecosystems and Intelligent Transportation Systems (ITSs) in real time.

1. Introduction

The rapid innovation in Intelligent Transportation Systems (ITSs) has amplified demands on vehicular communication infrastructure, demanding ultra-reliable and low-latency Vehicle-to-Everything (V2X) frameworks that reinforce safety-critical services. The present-day vehicular networks present cooperative awareness, autonomous coordination, collision avoidance, and real-time traffic optimization. Due to this smart infrastructure, vehicles, roadside units (RSUs), edge servers, and cloud platforms have become increasingly interconnected. As such, the communication infrastructure must support high device density, tight latency budgets, and secure service orchestration. In this context, edge–cloud integration and microservice-driven modularity emerge as key enablers of scalable and intelligent V2X ecosystems [1].

In contrast to these developments, however, there is a basic challenge still being undertaken in ensuring secure and ultra-low-latency communication in distributed vehicular settings. The transmission, propagation, edge processing, cloud processing and authentication segments constitute the end-to-end delay in a vehicle. In safety-critical V2X services, this accumulated delay should be limited to a hard real-time limit: even a few milliseconds of unplanned latency can result in compromised collision avoidance, vehicle coordination and responsiveness to emergent situations. Further, the severity of traffic increases network congestion, which increases security checks and service complexity. The current solutions are paired with threats such as scalability and resource-inefficiency without protective and reliable architecture. The cars continuously broadcast telemetry in urban settings, such as velocity, position, and traffic information, to the related RSUs and edge fragments of computing [2,3]. These data streams must be authenticated, processed, and disseminated in real time to facilitate adaptive traffic control, alerts of hazards, and assistance in cooperative driving. As the density of the platooning vehicles increases, cloud-centered architectures exhibit service bottlenecks and tightly coupled system designs limit extensibility.

The existing V2X architectures tend to rely either on monolithic service designs or centralized cloud infrastructures or casually coupled edge platforms. Even though this environment provides minimal connectivity, the security provisions are typically applied with heavyweight authentication schemes that lead to the growing response latency. Additionally, the current service management architectures do not usually possess the attributes needed to achieve a dynamically scalable nature in the presence of geographically dispersed nodes. Therefore, these environments are limited by: (i) high transmission and computation time in highly congested traffic by central processing; (ii) low modular scalability of monolithic designs; (iii) poor consistency of microservice management in distributed edge deployments; and (iv) the inability to combine lightweight but resilient authentication with high throughput latency. To address these problems, this study answers these research questions:

• RQ1: How can an edge–cloud system reduce end-to-end delays in V2X communication while remaining scalable?
• RQ2: How can secure authentication and data exchange be integrated without introducing prohibitive latency overhead?
• RQ3: How can a microservice-based design improve the flexibility and reliability of vehicular communication networks?

The objectives of this research include:

• O1: Designing a low-latency edge–cloud communication framework tailored for V2X networks.
• O2: Implementing a lightweight and secure authentication mechanism suitable for real-time vehicular data exchange.
• O3: Developing a microservice-based system architecture that is horizontally scalable, fault-tolerant, and extensible.

In order to accomplish these objectives, this paper presents an edge–cloud architecture based on a secure and high-performance intelligent V2X communication in the form of microservice components. The architecture can move tasks with latency constraints to edge nodes, and thus enhance data throughput, and use lightweight security mechanisms that do not impact responsiveness of the system. The key contributions to this work include: (1) A formal latency model for V2X systems with strict end-to-end delay constraints. (2) A microservice-based edge–cloud framework designed for intelligent vehicular networks. (3) A lightweight secure data exchange and authentication method optimized for real-time V2X use cases. (4) Experimental evaluation demonstrating significant latency and scalability improvements over centralized baselines.

The rest of this paper is structured in the following way. Section 2 describes related work on V2X systems, edge computing, microservice architectures, and lightweight vehicular security. The research methodology is detailed in Section 3 while the results are presented in Section 4. Section 5 discusses the overall research while Section 6 concludes the paper.

2. Related Work

V2X communication has become one of the pillars of next-generation Intelligent Transportation Systems (ITSs), allowing cooperative perception, road safety services, and intelligent traffic through the vehicle-to-vehicle (V2V), vehicle-to-infrastructure (V2I), and vehicle-to-network (V2N) communication [4]. The development of wireless networks and edge infrastructure suggests that the V2X space will not only proceed with primitive awareness messaging but also suggests that an entirely managed, service-based communication ecosystem will be achieved through a full orchestration of communication services in the V2X domain. The application of this field directly relates to safety-critical decision-making, massive mobility management, and the eco-friendly functioning of transportation systems in urban high-density areas where millisecond-latency and high reliability are key factors.

The major issue in this area is the ability to support rigorous end-to-end latency and reliability standards in dynamic operating environments like high vehicle mobility, episodic traffic flows, and intermittent connectivity conditions [5]. Secondary issues comprise scalable deployment of services over distributed edge–cloud infrastructures, interoperability across heterogeneous vendors and protocol stacks and robust security guarantees without prohibitive overhead. Such obstacles are multiplied by V2X standards moving in the direction of constant telemetry exchange, edge-centric intelligence, and multi-stakeholder integration of traffic authorities, emergency response, and cloud analytics providers and vendors [6].

The authors of [7] presented a comparative overview of V2X and vehicular networking architectures from communication modality, protocol stack, and deployment perspectives, tracing the transition from VANET-centered designs to service-oriented V2X ecosystems. The authors of [8] provided a wide-ranging review of edge-enabled vehicular networks, focusing on low-latency processing, data offloading models, and the orchestration requirements of real-time transportation services. Together, these surveys highlight the need for architectural designs that are scalable, modular, and secure within realistic edge–cloud environments.

The authors of [9] examined enabling technologies for next-generation vehicular communications, including ultra-low-latency connectivity, integrated sensing-and-communications, and AI-assisted network optimization. Their findings suggest that future vehicular services will require tight coupling of communications, computation, and intelligence across the edge–cloud continuum. Identified gaps include: (i) limited deployment-oriented frameworks for real-time service delivery, (ii) understudied application-layer orchestration under vehicular dynamics, and (iii) absence of end-to-end designs that jointly optimize latency and security. The authors of [10] investigated edge-computing strategies for V2X, proposing computation-offloading and task-scheduling mechanisms for vehicular workloads. Their simulation-based results showed reduced latency and improved resource utilization when safety-critical tasks were processed near the source. Remaining gaps include: (i) standardized service decomposition for extensibility, (ii) universal interfaces for heterogeneous node interoperability, and (iii) secure integration of lightweight authentication without compromising latency budgets.

The authors of [11,12] proposed microservice-based vehicular networking frameworks using lightweight authentication protocols, service decomposition, and containerized deployment. Their results show improved maintainability and elasticity under variable load. Persistent gaps include: (i) insufficient attention to latency-critical V2X pipelines, (ii) inadequate orchestration under mobility-driven churn at edge–cloud boundaries, and (iii) absence of integrated security workflows within microservice pipelines. The authors of [13] explored service orchestration for edge–cloud systems via container orchestration and dynamic scaling policies, demonstrating improved service availability and recovery. Remaining gaps include: (i) domain-specific orchestration for V2X message flows such as telemetry and cooperative awareness messages, (ii) real-time constraints under high mobility, and (iii) security-aware orchestration optimized for low-latency delivery.

The authors of [14] proposed lightweight security countermeasures against impersonation, replay, and denial-of-service attacks in vehicular networks, demonstrating reduced overhead compared to conventional public-key schemes. Remaining gaps include: (i) integration of security into distributed edge–cloud service architectures, (ii) session continuity under mobility, and (iii) preservation of real-time guarantees under large-scale authentication. The authors of [15] proposed a challenge-response authentication scheme for ITS, showing increased attack resistance with manageable latency in controlled environments. Gaps include: (i) scalability in microservice-driven deployments, (ii) limited evaluation under mixed workloads, and (iii) lack of end-to-end designs integrating edge processing with multi-tier security enforcement.

Collectively, existing studies promote edge-offloading methodologies, microservice-based design, and vehicular security protocols; however, no end-to-end, deployment-ready architecture simultaneously addresses low latency, modular service orchestration, and lightweight security for real-time V2X communications. Three key gaps motivate the present work: (i) absence of end-to-end edge–cloud designs treating V2X as a service-oriented pipeline with strict latency constraints; (ii) insufficient integration of microservice orchestration with real-time vehicular telemetry exchange under mobility; and (iii) lack of embedded lightweight security mechanisms that do not compromise responsiveness or scalability. This work addresses these limitations by proposing a secure and low-latency edge–cloud microservice architecture for intelligent V2X communications.

3. Research Methodology

We propose a latency-constrained, application-layer security framework for V2X communications deployed over a distributed edge–cloud microservice architecture. The proposed methodology is designed to satisfy the end-to-end latency constraint imposed by real-time vehicular applications. The architecture integrates secure registration, lightweight session authentication, and integrity-preserving telemetry exchange enforced through middleware-controlled Laravel microservices deployed at edge gateways.

3.1. System and Delay Model

Let $𝒱$ = {v₁, v₂, …, v_n} denote the vehicular set. Each vehicle v_i generates telemetry ψ_i(t) transmitted to the nearest edge node e_j ∈ $ℰ$.

From the canonical end-to-end delay model introduced in Section 1, the processing and authentication components can be further decomposed at the application layer. Specifically, the authentication and edge processing terms can be expanded as follows:

t_auth = t_reg + t_session

(1)

$$t_{\mathit{proc}}^{\mathit{edge}}=t_{\mathit{ver}}+t_{\mathit{edge}}$$

(2)

where t_reg denotes registration latency, t_session represents session authentication delay, t_ver denotes middleware verification overhead, and t_edge corresponds to application-layer edge processing. Latency-sensitive validation is executed at edge nodes to minimize t_edge, while cloud resources handle long-term analytics. Figure 1 shows the methodological flow of our proposed framework.

3.2. Secure Registration Phase

Each vehicle must securely establish its identity before participating in V2X communication. Let ID_i denote the identity of vehicle v_i. During registration, the vehicle generates a fresh nonce η_i and timestamp T₀, which are used to ensure request freshness and reduce replay risk. The secure registration process is presented in Algorithm 1. The use of timestamp validation and nonce-based binding ensures replay resistance and registration freshness.

Algorithm 1 Secure Registration Protocol

Input: Vehicle identity IDi

Output: Registration token Si

1: Generate a random nonce ηi

2: Generate current timestamp T0

3: Construct registration message M0 ← ⟨IDi, ηi, T0 ⟩

4: Send M0 to the edge gateway

5: Edge gateway verifies timestamp freshness: |Tserver − T0| ≤ Δt

6: if |Tserver − T0| > Δt then

7:     Reject registration request

8: else

9:     Compute registration token:

10:   $S_i\leftarrow \mathrm{HMA}{\mathrm{C}}_{K_s}\left(I{D}_i‖T_0‖{\eta }_i\right)$

11:   Store (IDi, Si) in the secure datastore

12:   Return encrypted registration token Si with expiry time

13: end if

3.3. Lightweight Authentication Phase

For each communication session, a lightweight challenge–response mechanism is used to establish trust while maintaining low computational overhead. The vehicle uses its registration token to generate an HMAC-based authentication signature, and the edge gateway verifies the token validity, timestamp freshness, and signature correctness before issuing a short-lived session token. The complete session authentication procedure is shown in Algorithm 2. The session token is short-lived to reduce attack surface and limit exposure in case of compromise.

Algorithm 2 Session Authentication Protocol

Input: Vehicle identity IDi, registration token Si

Output: Short-lived session token Ts

1: Generate current timestamp T1

2: Compute authentication signature:

3: ${\sigma }_{\mathrm{i}}\leftarrow \mathrm{HMA}{\mathrm{C}}_{{\mathrm{S}}_{\mathrm{i}}}(I{D}_i\Vert T_1)$

4: Send (IDi, σi, T1) to the edge gateway

5: Gateway verifies timestamp freshness, token validity, and signature correctness

6: if σi is invalid or Si is expired then

7:    Reject authentication request

8: else

9:    Generate server nonce ηs

10:  Generate current timestamp T2

11:  Generate encrypted session token:

12:  ${\mathrm{T}}_{\mathrm{s}}\leftarrow \mathrm{En}{\mathrm{c}}_{{\mathrm{K}}_{\mathrm{s}}}\left(\mathrm{I}{\mathrm{D}}_{\mathrm{i}}‖{\mathsf{\eta }}_{\mathrm{s}}‖{\mathrm{T}}_2\right)$

13:  Bind Ts with a limited time-to-live value

14:  Return signed session token Ts to vehicle vi

15: end if

3.4. Secure Telemetry Exchange

After successful authentication, telemetry communication proceeds with integrity protection and replay prevention. Each telemetry payload is bound with a fresh nonce, timestamp, session token, and HMAC signature so that the edge gateway can detect expired tokens, reused nonces, and modified payloads before forwarding the data to the microservice queue. The secure telemetry transmission procedure is described in Algorithm 3. Nonce tracking prevents replay attacks, while HMAC ensures payload integrity.

Algorithm 3 Secure Telemetry Transmission

Input: Session token Ts, payload ψi, registration token Si

Output: Verified and forwarded telemetry payload

1: Generate random nonce νi

2: Generate current timestamp T3

3: Compute telemetry signature:

4: ${\omega }_{\mathrm{i}}\leftarrow {\mathrm{HMAC}}_{{\mathrm{S}}_{\mathrm{i}}}(T_s\Vert {\nu }_i\Vert T_3\Vert {\psi }_{\mathrm{i}})$

5: Construct telemetry packet:

6: M1 ← ⟨Ts, ψi, νi, T3, ωi⟩

7: Send M1 to the edge gateway

8: Gateway verifies session token, nonce uniqueness, timestamp freshness, and signature

9: if Ts is expired or νi is reused or ωi is invalid then

10:   Reject telemetry packet

11: else

12:   Forward validated payload ψi to the edge microservice queue

13:   Acknowledge successful reception

14: end if

3.5. Edge–Cloud Microservice Orchestration

The proposed architecture distributes responsibilities hierarchically. The edge layer performs security validation and latency-critical decision logic while the cloud layer performs aggregation, pattern extraction, and long-term analytics. To reduce blocking latency, Laravel-based middleware performs pre-validation before forwarding payloads to asynchronous queue workers (e.g., SQLite-backed jobs). This ensures the following:

t_ver + t_edge ≪ t_cloud

(3)

The stateless microservice design enables horizontal scaling under increasing vehicular density.

3.6. Security and Performance Characteristics

The proposed methodology guarantees the following:

• Confidentiality via encrypted session tokens;
• Integrity via HMAC validation;
• Freshness via timestamp constraints;
• Replay resistance via nonce tracking;
• Scalability via stateless microservices;
• Latency preservation via edge validation.

Thus, the framework satisfies the latency constraint τ_i ≤ τ_max while ensuring secure and scalable V2X communication in distributed vehicular environments.

3.7. Implementation

This security framework has been implemented using lightweight microservices through the Laravel framework. Laravel was selected due to its modular structure, in-built security features, and high scalability in creating RESTful APIs. The system consists of three fundamental elements: vehicle registration, session authentication and transmission of telemetry. All components are exposed via specialized API endpoints on the gateway layer. Security checks are applied through the middleware and they include: timestamp validation, HMAC validation, token validation, replay-attack mitigation and request rate limiting. The architecture is stateless and no server-side session state is stored; this is better than the one that enables horizontal scalability and consumes less memory. Authentication tokens are created by cryptographic functions in line with the security specifications stated in Section 3 and are attached to a Time-to-Live (TTL) to limit the exposure in the event of compromise.

To achieve high throughput, SQLite-backed queues handle incoming telemetry payloads asynchronously, preventing blocking operations and ensuring that the latency constraint τ_i ≤ τ_max is respected. Upon successful security validation, payloads are dispatched to background workers or forwarded to cloud services.

Postman was used to validate the system where vehicular clients were simulated through all three communication phases. Structured JSON test data were used to check the freshness of the timestamps, the uniqueness of the nonces, the correctness of the signature, and appropriate handling of the session. The automated test suites were also used to test both nominal and failure cases such as replay attempts, token expired and signature tampering in addition to measuring response time to test API responsiveness under repeated request conditions. Its implementation is hence a practical actualization of the elaborated edge–cloud security architecture, and it shows its feasibility and adaptability in meeting practical real-time V2X communication needs.

4. Results

Latency was recorded between two edge-centric and centralized infrastructures with one-hundred consecutive replicated requests. All measurements had the steps of user registration, authentication, middleware verification, and telemetry dispatch. As the empirical evidence demonstrates, the response times are considerably decreased because of the local security validation at the edge level and the adoption of asynchronous microservice orchestration methods.

Table 1. Latency statistics in milliseconds.

Statistic	Edge-Based	Centralized
Count	100	100
Mean	2.58	82.34
Standard deviation	0.79	13.92
Minimum	2.03	57.48
25th percentile	2.21	73.65
Median	2.36	84.11
75th percentile	2.59	95.72
Maximum	7.94	105.28

presents the latency statistics and they are in milliseconds.

The system was tested in three protocol phases, i.e., (i) registration, (ii) authentication, and (iii) telemetry submission (communication). The analysis of the response time is presented in

Table 2. Response-time analysis for V2X API endpoints in milliseconds.

Request No.	Status	Size (Bytes)	Total (ms)	DNS (ms)	TCP (ms)	Transfer (ms)	Download (ms)
/api/v1/device/register
1	200	420	140.52	2.10	118.00	1.10	5.32
2	200	420	96.74	1.60	80.00	0.80	4.34
3	200	420	45.28	0.90	35.00	0.40	3.98
/api/v1/device/authenticate
1	200	690	178.41	2.40	150.00	1.20	6.81
2	200	690	122.58	1.80	102.00	0.90	5.88
3	200	690	58.36	0.80	45.00	0.50	4.06
/api/v1/device/telemetry
1	202	315	121.77	1.60	98.00	0.70	4.47
2	202	315	78.42	1.10	62.00	0.50	4.82
3	202	315	29.84	0.40	18.00	0.20	3.24

.

The findings indicate a general enhancement in all the endpoints primarily because middleware validation is optimized, nonce caching is improved, and asynchronous job dispatch is backed by SQLite (3.53.2).

The empirical findings show that once a TCP connection is established and reused across subsequent requests, significant performance gains are observed. This behavior is consistent with connection keep-alive reuse, which eliminates repeated connection-setup overhead. Additionally, middleware nonce caching contributes to a reduced per-request processing time. Telemetry endpoints exhibit the lowest steady-state latency among the evaluated interfaces, supporting the design decision to offload payload processing to asynchronous queue workers, thereby decoupling validation overhead from the request–response cycle.

Throughput assessment showed improved request-handling capacity for the edge layer due to the use of a stateless microservice architecture and lightweight session validation. The system handled higher request concurrency with no measurable latency degradation and, hence, is shown to provide effective horizontal scalability. The stability of the latency distribution, as indicated by a decreasing standard deviation, supports the claim that the implemented security mechanisms do not introduce highly unpredictable overhead. Rather, middleware-based validation and nonce caching maintain consistent response times despite high-frequency repeated telemetry submissions.

5. Discussion

The experimental results show that applying security enforcement mechanisms at the edge layer substantially reduces end-to-end latency while maintaining strong application-layer protection. Compared with centralized validation models, the proposed architecture provides faster response times, lower latency variation, and improved scalability. The edge-based deployment achieved a mean response time of 2.58 ms, whereas the centralized baseline required 82.34 ms on average. This difference indicates that latency-sensitive V2X operations benefit significantly when authentication, token verification, nonce checking, and telemetry validation are performed close to the vehicular source instead of being forwarded to a distant centralized server. The endpoint-level results further support the design choice of separating security validation from long-running processing tasks. Registration and authentication requests show relatively higher response times because they involve identity verification, timestamp checking, HMAC signature validation, and token generation. However, the response time decreases across repeated requests, mainly due to TCP connection reuse and reduced connection-establishment overhead. In contrast, telemetry submission achieves the lowest steady-state response time because the validated payload is immediately forwarded to asynchronous queue workers. This confirms that non-blocking telemetry processing is effective for preserving responsiveness in real-time V2X communication.

From a security and scalability perspective, the proposed framework provides a practical balance between protection and latency efficiency. HMAC-based validation ensures message integrity, timestamp verification supports freshness, nonce tracking limits replay attacks, and short-lived encrypted session tokens reduce the risk of long-term credential exposure. Since these mechanisms are implemented through lightweight edge middleware and a stateless microservice design, the framework avoids heavy centralized authentication overhead and can be scaled by adding more edge nodes when vehicular density increases. Consequently, these results demonstrate that the framework fulfils the latency constraint τ_i ≤ τ_max and enables secure real-time V2V, V2I, and V2X communication in high-density vehicular environments. Nevertheless, the evaluation is currently based on API-level emulation using repeated request scenarios. Although this setup is useful for measuring registration, authentication, and telemetry response times, future validation should include larger-scale vehicular mobility simulations, varying network conditions, different traffic densities, and real RSU-edge deployment settings. Further experiments may also compare the proposed architecture with additional state-of-the-art V2X authentication and edge–cloud orchestration models.

6. Conclusions

This paper presents a secure and low-latency edge–cloud architecture for intelligent V2X communications, based on a microservice-driven design paradigm. Diverging from conventional centralized or monolithic vehicular architectures, the proposed system distributes latency-sensitive security validation and telemetry processing tasks to edge gateways, thereby reducing end-to-end communication delay while preserving scalability and robustness. A formal latency model ensures that the accumulated per-vehicle delay τ_i remains within stringent real-time constraints. To fulfil this need, the framework combines safe registration, minimal session authentication, integrity-surpassed telemetry exchange with HMAC-based cryptographic primitives, nonce tracking, timeless validation and short-lived encrypted session tokens. All these mechanisms ensure data confidentiality, integrity, freshness guarantees, and replay attack prevention while having light computational burden. The architecture is built with the Laravel framework, security checks are provided by middleware, and asynchronous job queues are implemented with SQLite as the backing store, meaning they would not block the ingestion of telemetry. The stateless service design allows horizontal scaling and minimizes the latency of processing vehicular data. Experimental analysis with emulated API requests demonstrates that the edge-based deployment, with a mean response time of 2.58 ms (which is significantly smaller than the centralized baseline), and variable variance are stable when repeated requests are made. These findings suggest that it is possible to successfully implement application-layer security in V2X communication pipelines without affecting the real-time performance requirements. Further work will be conducted on validation in more realistic conditions of the vehicular network, such as in high-mobility cases and large-scale load concurrently, alongside comparisons with other state-of-the-art solutions.