On-device artificial intelligence (AI) is a system that works on mobile devices, such as smartphones and laptops, as well as other wearables. It is more independent because it can be used on the go without an internet connection. This is just one of the advantages of these systems. Another is the privacy benefits of local processing, as there is no outgoing data traffic or need to store user or sensitive data on remote servers. Local AI also has the advantage of lower latency compared to cloud models. Due to its built-in nature, it can be very fast (of course, depending on the device), and eliminates the additional costs that a cloud model would inevitably incur.

Another use case for local models would be assistance through “ambient computing”, where the device anticipates user needs based on on-screen context.An example is Magic Cue on Android 16, which runs locally to offer relevant actions based on the user’s current activity.

Technical Background:

Deploying Large Language Models (LLMs) locally requires overcoming significant hardware constraints, specifically limited memory or RAM, battery life, and thermal limits. To run models larger than the device’s physical RAM, frameworks use flash storage to store the needed data, dynamically loading only the “active” weights needed for the current token generation into RAM. This allows devices with limited RAM (e.g., 8GB) to run larger models. Also specific cpus with dedicated Neural Processing Units (NPUs) like the Snapdragon 8 Gen 3 utilizing these to squeeze out a little bit more performance to run even bigger complexer models. They are also faster in delivering higher token-per-second rates. Google famously focused their chips called Tensor to have Tensor Processing Units which results in even better performance and efficiency for their models across the board.

Quantization

But how can you fit large models onto such a tiny device while taking hardware concerns into account? It works with quantisation. This technique compresses a model to a much smaller size. It’s much like compressing a folder or file into a zip file on your PC. AI models are normally trained using a format called FP32. If you have a ‘7 billion parameter’ model (such as Llama 3 or Qwen), each parameter requires 4 bytes. However, when you do the maths with such a model: 7 billion x 4 bytes = 28 GB of RAM. However, most smartphones only have 8 or 12 GB of RAM in total, and even if they share some of the normal SSD memory, the model simply will not fit. Quantisation is the process of converting these large models from FP32 to INT8 or INT4. Going from 32-bit to 4-bit usually results in very little loss of intelligence, often less than a 1% drop in accuracy. Alternatively, you can think of the process as compressing an image. Most of the detail remains; only the extreme details are lost in the process.

Software and Ecosystem:

Local AI is supported by a software stack designed to abstract hardware complexities.
Google’s Gemini Nano is a prime example of a multimodal model developed specifically for on-device efficiency. It comes in different sizes to accommodate different devices and their performance capabilities. Frameworks such as LiteRT-LM enable developers to create custom LLM pipelines that can be used on Android, iOS and web platforms. LiteRT-LM is a relatively low-level tool that is not commonly used by developers. The ML Kit GenAI API is a more commonly used tool for this purpose, leveraging local models. It offers native APIs for Kotlin/Java, Swift and JavaScript, enabling deployment of the same model across different platforms. However, there are also different options available for each ecosystem.

Android

ML Kit GenAI API is probably the most straightforward and user-friendly toolset to implement for Android developers in particular. It completely abstracts away model management by interfacing with Android AICore. As it uses the built-in Gemini Nano model, there is no need to bundle a large model with your app. It offers pre-built APIs for common tasks, so there is no need to design prompts. These include summarising text passages, proofreading, rewriting, and providing smart replies. If you require greater flexibility than that offered by the above-mentioned specific tasks, the GenAI Prompt API enables you to send natural language requests directly to Gemini Nano.

Web
For web applications, Google is integrating high-level AI capabilities directly into the Chrome browser. Similar to the Android approach, this allows web developers to access on-device Gemini Nano models through JavaScript APIs without requiring the user to download heavy libraries or models for each site.

iOS

For iOS 18+, developers can use system-level APIs to access Apple’s on-device foundation models for text generation and embeddings, removing the need for third-party libraries

While Google promotes the ML Kit GenAI API for Gemini, the API explicitly supports “other open models” and “open-weight models” like mistral, llama or gemma. It just abstracts the complexity of the low-level LiteRT-LM engine to be accessible to more developers.

Conclusion:

On-device AI represents a critical step forward for user sovereignty. By processing data locally on dedicated NPUs, we eliminate the need to send sensitive information to remote servers, solving the twin challenges of latency and privacy in one go. While tasks requiring immense computational power will remain in the cloud, the “thinking” that happens on our smartphones is getting smarter, faster, and more personal. For the end user, this means a device that is not just a portal to the internet, but a truly intelligent assistant that works anywhere, anytime.

References:

• https://www.applivery.com/blog/news/google-pixel-10/
• https://www.researchgate.net/profile/Dwith-Chenna/publication/373329073_EDGE_AI_QUANTIZATION_AS_THE_KEY_TO_ON-DEVICE_SMARTNESS/links/64e627b60453074fbda950d6/EDGE-AI-QUANTIZATION-AS-THE-KEY-TO-ON-DEVICE-SMARTNESS.pdf
• https://arxiv.org/html/2512.06490v1
• https://developers.googleblog.com/on-device-genai-in-chrome-chromebook-plus-and-pixel-watch-with-litert-lm/
• https://nearform.com/digital-community/ai-beyond-the-cloud-the-current-and-future-state-of-on-device-generative-ai/

The post Technical Revolution – On-Device AI appeared first on Mobile USTP MKL.

Unlike many existing budgeting applications that rely on online accounts and cloud storage, HomeBudget+ works entirely offline using a local database on the user’s device. This approach ensures maximum privacy while still offering practical features such as login functionality, structured expense tracking, and a clean mobile user interface.

Project Goals and Scope

The primary goal of the first semester was to establish a solid technical foundation and implement the core functionality of the application. The defined scope included:

• Implementing a secure user login system.
• Building an expense tracking system with categorized entries.
• Enabling full CRUD operations (create, edit, delete expenses).
• Allowing users to define budgets per category and time period.
• Storing all financial data locally on the device for offline usage.
• Designing a responsive and mobile-optimized user interface.

Tools and Technologies

To implement HomeBudget+, the following tools and technologies were used:

• Framework: Ionic + Angular – for cross-platform mobile development.
• Database: SQLite or Capacitor Storage – for secure local data storage.
• Authentication: Local login system.
• Design & Prototyping: Figma – for UI mockups and user flow planning.
• Version Control: Git and GitHub.
• Development Tools: Visual Studio Code, Chrome DevTools, Android Emulator.

Implementation Process

Due to the limited timeframe of approximately 100 hours, the development process focused primarily on functionality and system architecture. The first step was planning the application structure, database schema, and expense categories.

After that, the login functionality and core expense management logic were implemented. This included adding, editing, and deleting expense entries as well as defining budgets per category. All data was stored locally to ensure offline functionality.

The final phase consisted of testing, basic UI refinement, and documentation.

What’s Included in the First Semester

• User login functionality.
• Expense tracking with multiple categories (e.g., Rent, Food, Transport, Utilities, Insurance, Entertainment).
• Budget definition per category and time range.
• Local offline data storage.
• Core application logic and data handling.
• A clean and responsive mobile UI foundation.

What’s Next

In the next development phases, the focus will be on automation, analytics, and improved user experience. Planned future features include:

• Bank integration:
  The app will connect directly to the user’s bank software or banking APIs. Expenses will be imported automatically and assigned to the correct categories without manual input.
• Visual expense reports using bar and pie charts.
• Payment reminders and notification system.
• Further improvements to the simple and responsive user interface.
• Optional advanced features such as data export, backups, and AI-based budgeting suggestions.

Overall, the first semester successfully established a strong foundation for a privacy-focused and scalable personal finance application. With the core logic, login system, and offline architecture in place, HomeBudget+ is well prepared for future expansion.

The post HomeBudget+ – 1st Semester Project appeared first on Mobile USTP MKL.

Web performance has become a critical quality attribute of modern web applications. Users expect fast load times, smooth interactions, and responsive interfaces, regardless of device or network conditions. From a business perspective, performance directly affects user retention, conversion rates, and search engine visibility.

Modern frontend frameworks such as React, Angular, and Vue have significantly improved developer productivity and application maintainability. However, these frameworks often rely heavily on JavaScript and client-side rendering, which can introduce performance challenges if not handled carefully.

This blog post examines web performance optimization in the context of modern frontend frameworks. It explains the technical foundations of web performance, identifies common performance bottlenecks, discusses key optimization techniques, and compares how popular frameworks address performance concerns.

What Is Web Performance Optimization?

Web performance optimization refers to the process of improving how quickly and efficiently a web application loads, renders, and responds to user interactions. From a technical perspective, performance is influenced by multiple factors, including network latency, resource size, browser rendering behavior, and JavaScript execution.

A central concept in this context is the Critical Rendering Path (CRP). The CRP describes the sequence of steps a browser takes to convert HTML, CSS, and JavaScript into pixels on the screen. Blocking resources, excessive JavaScript execution, or inefficient rendering strategies can significantly delay this process.

Performance is commonly measured using standardized metrics. Google’s Core Web Vitals have become especially important, as they are used as ranking signals in search results:

• Largest Contentful Paint (LCP) measures loading performance.
• First Input Delay (FID) measures interactivity.
• Cumulative Layout Shift (CLS) measures visual stability.

Optimizing these metrics is a primary goal of modern frontend performance engineering.

Modern Frontend Frameworks and Performance Challenges

Modern frontend frameworks are typically used to build Single Page Applications (SPAs). In SPAs, a large portion of the application logic is executed on the client side. While this enables rich interactivity, it also shifts more responsibility to the browser.

One of the main challenges is JavaScript execution cost. Large JavaScript bundles must be downloaded, parsed, compiled, and executed before the application becomes interactive. This can block the main thread and delay user input handling, especially on low-end devices.

Another challenge is hydration in applications that use server-side rendering. During hydration, the browser attaches event listeners and internal framework state to pre-rendered HTML. Although this improves perceived load time, it introduces additional runtime overhead.

Framework abstractions such as the Virtual DOM also add a performance trade-off. While they simplify UI updates, inefficient component design or unnecessary re-renders can still negatively impact performance.

Key Performance Optimization Techniques

Code Splitting and Lazy Loading

Code splitting allows applications to divide JavaScript bundles into smaller chunks that are loaded on demand. Instead of delivering the entire application upfront, only the code required for the current view is fetched.

Lazy loading builds on this idea by deferring the loading of non-critical components, routes, or images until they are actually needed. Modern bundlers such as Webpack, Vite, and Rollup provide built-in support for these techniques.

These approaches significantly reduce initial load time and improve time-to-interactive.

Tree Shaking and Bundle Optimization

Tree shaking is a build-time optimization that removes unused code from JavaScript bundles. It relies on static analysis of ES module imports and exports.

By eliminating dead code, bundle size can be reduced considerably, which leads to faster downloads and lower parsing costs. Effective tree shaking requires careful dependency selection and proper module syntax.

Rendering Strategies: CSR, SSR, and SSG

Frontend applications can use different rendering strategies:

• Client-Side Rendering (CSR) renders content entirely in the browser. It offers high interactivity but often results in slower initial load times.
• Server-Side Rendering (SSR) generates HTML on the server for each request, improving initial render speed and SEO.
• Static Site Generation (SSG) pre-renders pages at build time, providing excellent performance for content-heavy or mostly static applications.

Each strategy has trade-offs related to infrastructure complexity, build time, and runtime performance. Modern frameworks increasingly support hybrid approaches that combine these strategies.

Memoization and Rendering Optimization

Frameworks like React and Vue provide mechanisms such as memoization to avoid unnecessary re-renders. Techniques like useMemo, useCallback, and component-level memoization help reduce computational overhead during UI updates.

Efficient state management and careful component design are essential to fully benefit from these optimizations.

Framework-Specific Approaches

React

React emphasizes fine-grained component updates through its reconciliation algorithm. Performance optimization in React relies heavily on proper component structuring, memoization, and avoiding unnecessary state changes.

Frameworks built on top of React, such as Next.js, add advanced performance features like SSR, SSG, and automatic code splitting.

Angular

Angular provides a more opinionated structure and includes built-in performance tools such as Ahead-of-Time (AOT) compilation and change detection strategies. While Angular applications tend to have larger initial bundles, its tooling supports systematic optimization.

Vue

Vue offers a balance between flexibility and performance. Its reactivity system enables efficient updates, and Vue’s ecosystem provides strong support for code splitting and SSR through frameworks like Nuxt.

Use Cases: When Optimization Matters Most

Web performance optimization is particularly critical for:

• Mobile-first applications
• Content-heavy platforms
• E-commerce websites
• Applications targeting regions with limited network bandwidth

In internal tools or applications with a controlled user base, extreme optimization may be less critical, and developer productivity may take priority.

Limitations and Trade-Offs

Performance optimization introduces additional complexity. Advanced build pipelines, multiple rendering strategies, and caching layers increase maintenance effort and infrastructure costs.

Furthermore, premature optimization can lead to over-engineering. Performance work should therefore be guided by real measurements, such as browser performance audits and user monitoring data.

Conclusion

Web performance optimization is a fundamental aspect of modern frontend development. While modern frameworks offer powerful abstractions and tooling, they do not eliminate the need for careful performance engineering.

By understanding browser rendering behavior, choosing appropriate rendering strategies, and applying proven optimization techniques, developers can build fast, responsive, and scalable web applications. Ultimately, successful performance optimization requires balancing technical complexity with measurable user experience improvements.

Sources

• https://developer.mozilla.org/en-US/docs/Web/Performance
• https://web.dev/performance/
• https://web.dev/vitals/
• https://developers.google.com/web/fundamentals/performance/critical-rendering-path
• https://react.dev/learn/render-and-commit
• https://nextjs.org/docs/app/building-your-application/optimizing
• https://angular.io/guide/performance
• https://vuejs.org/guide/best-practices/performance.html
• https://nuxt.com/docs/guide/concepts/rendering
• https://webpack.js.org/guides/code-splitting/
• https://www.linkedin.com/pulse/boosting-front-end-performance-modern-frameworks-kamal-boukar-ov6me

The post Web Performance Optimization in Modern Frontend Frameworks appeared first on Mobile USTP MKL.

The paper further analyzes quantitative and qualitative risk assessment methods and discusses emerging security solutions such as AI-driven threat detection, biometric authentication, and edge computing architectures.

Keywords
Mobile Banking, Security Vulnerabilities, Risk Assessment, Cybersecurity, Authentication

1  Introduction

Mobile banking applications have rapidly evolved as a primary channel for financial services, providing convenience, flexibility, and 24/7 accessibility to millions of users worldwide. With the widespread adoption of smartphones and mobile networks, users can perform transactions, check balances, pay bills, and manage investments directly from their mobile devices.

Effective risk assessment approaches are crucial to identify, prioritize, and mitigate these security weaknesses. Traditional risk assessment frameworks often rely on static analysis, code reviews, and penetration testing; however, modern approaches integrate dynamic behavior analysis, real-time monitoring.

2 Security Vulnerabilities in Mobile Banking Applications

Mobile banking applications have become an integral part of financial services, enabling users to perform transactions, check balances, and manage accounts directly from their mobile devices. However, this convenience comes with significant security challenges. Mobile banking applications are vulnerable to a variety of threats, ranging from insecure data storage and transmission to weak authentication mechanisms. According to Batool and Kanwal (2025), the adoption of serverless and edge computing architectures in financial applications introduces both opportunities and risks, as computation and storage occur closer to users, which may expose sensitive data if not properly secured.

One of the most critical vulnerabilities is related to authentication and authorization. Many mobile banking applications rely on traditional password-based methods or PINs, which are susceptible to brute-force attacks, phishing, and credential theft (Varghese et al., 2016). Multi-factor authentication (MFA) has been suggested as a more secure approach; however, improper implementation or user negligence can still leave accounts at risk. Additionally, insecure session management may allow attackers to hijack active sessions, gaining unauthorized access to user accounts (Javed et al., 2021).

Data storage vulnerabilities are another significant concern. Mobile applications often store sensitive information locally on the device, including account details, authentication tokens, and transaction histories. If this data is not encrypted properly, malware or physical access to the device can lead to serious breaches (Fazil et al., 2025). Moreover, insufficient encryption during data transmission over networks exposes mobile banking traffic to man-in-the-middle (MITM) attacks, potentially compromising confidential information such as credentials or transaction data.

Furthermore, application logic flaws can create exploitable gaps. For example, inadequate input validation and error handling may allow attackers to inject malicious code, leading to unauthorized operations or data leakage (Cao et al., 2020). Similarly, the integration of third-party libraries or APIs without rigorous security assessment can introduce hidden vulnerabilities, as external components may not adhere to the same security standards as the core application (Gupta, 2024).

Finally, device-level vulnerabilities play a crucial role. Mobile banking applications depend on the underlying operating system and hardware security features. Jailbroken or rooted devices bypass standard security protections, making applications more susceptible to tampering, keylogging, and malware attacks (Siidorow, 2024). Even with secure devices, outdated operating systems or unpatched security flaws can provide attackers with opportunities to exploit the application.

Overall, mobile banking applications face a complex landscape of vulnerabilities that span software, hardware, and network layers. Addressing these risks requires a comprehensive approach that combines secure coding practices, robust authentication, encrypted data storage and transmission, and continuous monitoring for emerging threats.

3 Risk Assessment Approaches in Mobile Banking Applications
Risk assessment in mobile banking applications is a critical process aimed at identifying, analyzing, and mitigating potential security threats that could compromise sensitive financial data. Several methodologies have been proposed and applied in recent research, focusing on both technical vulnerabilities and user-related risks (Iqra Batool & Sania Kanwal, 2025; Fazil et al., 2025).

One widely used approach is quantitative risk assessment, which evaluates risks based on numerical probabilities and potential impacts. This method often involves calculating the likelihood of specific attacks, such as phishing, malware injection, or man-in-the-middle attacks, and then estimating the financial or operational losses that could result. Quantitative methods allow organizations to prioritize security measures by focusing on vulnerabilities with the highest risk scores (Cao et al., 2020).

Complementing quantitative methods, qualitative risk assessment relies on expert judgment and scenario analysis to evaluate potential threats. Security experts examine the architecture of mobile banking applications, including authentication mechanisms, API endpoints, and encryption protocols, to identify weak points. This approach often employs frameworks like OWASP Mobile Security Testing Guide (MSTG) to systematically assess vulnerabilities (Varghese et al., 2016).

Recent studies emphasize hybrid approaches, combining quantitative metrics with qualitative insights to create a more comprehensive risk profile. For instance, integrating statistical threat modeling with expert-driven scenario evaluation provides both measurable risk values and strategic recommendations for mitigation (Gupta et al., 2025). Hybrid methods are particularly useful in mobile banking, where user behavior and device heterogeneity introduce complexities not captured by purely quantitative models.

Additionally, automated risk assessment tools are gaining prominence. These tools scan mobile applications for known vulnerabilities, insecure code practices, and misconfigured security policies. Tools like static and dynamic analyzers, vulnerability scanners, and AI-driven detection systems help developers identify issues early in the software development lifecycle, reducing the likelihood of exploitable flaws reaching production (Siidorow, 2024).

A key challenge in mobile banking risk assessment is accounting for emerging threats such as biometric spoofing, AI-powered social engineering attacks, and zero-day vulnerabilities. Researchers suggest continuous monitoring and adaptive risk evaluation, leveraging machine learning models that analyze transaction patterns, user behavior, and network anomalies in real time (Tyagi, 2025). Such approaches allow banks to respond proactively rather than reactively, minimizing potential financial losses and reputational damage.

Finally, risk assessment in mobile banking must consider regulatory compliance and data privacy standards. Frameworks like GDPR, PSD2, and ISO/IEC 27001 impose specific requirements on data handling, authentication, and encryption. Integrating compliance checks within risk assessment ensures that security measures are both effective and legally aligned (Fazil et al., 2025).

4 Detailed Classification of Security Vulnerabilities
Mobile banking applications are inherently exposed to a wide range of security vulnerabilities due to their complex architectures, reliance on network communication, and integration with third-party services. These vulnerabilities can be broadly categorized into technical flaws, user-induced risks, and infrastructural weaknesses (Iqra Batool & Sania Kanwal, 2025; Varghese et al., 2016).

4.1 Technical Vulnerabilities
Technical vulnerabilities often arise from flaws in software design, coding errors, and insecure APIs. Common issues include improper input validation, weak encryption mechanisms, hard-coded credentials, and insufficient session management. For example, insecure storage of sensitive data such as login credentials, transaction information, or biometric data on mobile devices can allow attackers to extract confidential information if the device is lost, stolen, or compromised (Siidorow, 2024).

API endpoints are particularly critical in mobile banking, as insecure APIs can allow unauthorized access, data manipulation, or transaction hijacking. Research highlights that poorly designed APIs, lack of authentication, and absence of rate-limiting can result in severe breaches, compromising both user privacy and financial integrity (Fazil et al., 2025; Gupta et al., 2025).

4.2 Network and Communication Vulnerabilities
Mobile banking applications frequently depend on wireless communication networks, which exposes them to threats such as man-in-the-middle (MITM) attacks, packet sniffing, and session hijacking. Weak implementation of TLS/SSL protocols or improper certificate validation can allow attackers to intercept or manipulate data during transmission. Edge cases include attacks on mobile network operators, insecure Wi-Fi hotspots, or compromised VPNs (Tyagi, 2025).

4.3User-InducedVulnerabilities
End users contribute significantly to security risk. Common user-induced vulnerabilities include weak passwords, usage of rooted or jailbroken devices, installation of malicious apps, and susceptibility to phishing attacks. User education and behavioral monitoring are therefore essential components of any comprehensive security strategy (Batool & Kanwal, 2025). Behavioral analytics and adaptive authentication mechanisms—such as device fingerprinting, geolocation checks, and biometric verification—help mitigate risks caused by human factors (Cao et al., 2020).

4.4 Infrastructural and Systemic Vulnerabilities
Mobile banking systems rely on a distributed infrastructure, including cloud servers, third-party payment gateways, and backend databases. Insecure configuration, improper server hardening, and outdated software versions can open systemic vulnerabilities. Edge computing, while improving performance and latency, introduces additional security challenges as computation moves closer to potentially untrusted environments (Varghese et al., 2016; Gupta, 2024).

Additionally, the rapid adoption of technologies such as serverless functions, microservices, and containerized environments in mobile banking increases attack surfaces. Misconfigurations in these environments can lead to unauthorized access, privilege escalation, or resource exhaustion, threatening application integrity (Siidorow, 2024).

4.5 Emerging Threats
Emerging threats in mobile banking include AI-powered social engineering, biometric spoofing, deepfake attacks, and malware targeting payment credentials. Attackers exploit these vulnerabilities to bypass authentication, manipulate transactions, or compromise sensitive financial data. Continuous monitoring, anomaly detection, and integration of AI-driven threat intelligence are increasingly recommended to counter these sophisticated attacks (Tyagi, 2025; Javed et al., 2021).

4.6 Mitigation Strategies
Mitigating security vulnerabilities in mobile banking applications requires a multi-layered approach:

1. Secure Coding Practices: Adoption of guidelines such as OWASP Mobile Top 10 to minimize software flaws.
2. Strong Authentication & Authorization: Multi-factor authentication (MFA), biometric checks, and session management protocols.
3. Encryption & Data Protection: End-to-end encryption, secure storage, and proper handling of sensitive data.
4. Regular Security Testing: Automated vulnerability scanning, penetration testing, and code audits.
5. User Awareness Programs: Educating users on secure usage, phishing prevention, and device hygiene.
6. Infrastructure Hardening: Securing servers, APIs, third-party integrations, and cloud-edge components (Fazil et al., 2025; Gupta et al., 2025).

By addressing these vulnerabilities comprehensively, mobile banking providers can significantly reduce the risk of data breaches, fraud, and regulatory non-compliance, while ensuring trust and safety for end-users

5 Emerging Trends and Future Directions in Mobile Banking Security

Mobile banking security continues to evolve rapidly due to technological advancements, increasing cyber threats, and changing user behavior. Understanding emerging trends is critical for designing resilient, future-proof systems that safeguard sensitive financial information while maintaining usability and performance.

5.1 Integration of Artificial Intelligence and Machine Learning
Artificial intelligence (AI) and machine learning (ML) are becoming integral to mobile banking security. These technologies allow real-time anomaly detection, fraud prevention, and adaptive authentication. By analyzing patterns of user behavior, AI systems can identify unusual transactions, detect potential account takeovers, and mitigate phishing attacks more effectively than traditional rule-based systems (Iqra Batool & Sania Kanwal, 2025; Javed et al., 2021).

Machine learning models can be deployed on edge nodes to monitor network traffic and app usage locally, which reduces latency and preserves privacy. This integration enables proactive security measures, such as automatically flagging suspicious transactions or temporarily restricting access when high-risk behavior is detected (Varghese et al., 2016; Gupta, 2024).

5.2 Biometric and Multi-Factor Authentication Enhancements
The reliance on biometric authentication—such as fingerprint, facial recognition, and voice verification—is increasing in mobile banking. Advances in sensor technology and secure storage mechanisms allow mobile applications to implement biometric authentication that is both convenient and resistant to spoofing (Siidorow, 2024).

Multi-factor authentication (MFA) is also evolving to include adaptive factors, such as geolocation, device fingerprinting, and behavior-based verification. These contextual factors enhance security without negatively impacting the user experience, creating a balance between convenience and protection (Tyagi, 2025).

5.3 Blockchain and Distributed Ledger Technologies
Blockchain technology is emerging as a promising approach for enhancing data integrity and transparency in mobile banking systems. Distributed ledgers provide tamper-evident transaction records and decentralized validation, which can reduce the risk of fraud and unauthorized modifications (Cao et al., 2020).

Blockchain integration can also facilitate secure peer-to-peer payments and digital asset management within mobile banking applications. While this technology offers strong security guarantees, its implementation must be carefully managed to ensure scalability, latency, and regulatory compliance (Fazil et al., 2025).

5.4 Zero Trust Architecture and Micro-Segmentation
The adoption of zero trust principles is becoming critical for mobile banking applications. In this approach, no entity—whether inside or outside the network—is automatically trusted. Continuous verification of user identity, device integrity, and transaction legitimacy is enforced at every interaction (Varghese et al., 2016).

Micro-segmentation complements zero trust by dividing the network and application components into isolated segments. This limits lateral movement by attackers and reduces the impact of potential breaches. For mobile banking applications, these strategies help prevent unauthorized access to sensitive services and backend resources (Batool & Kanwal, 2025).

5.5 Cloud-Edge Security Convergence
The increasing reliance on cloud-edge architectures for mobile banking applications necessitates integrated security measures across distributed environments. Edge computing improves performance and latency but introduces new attack surfaces. Security strategies must include encrypted communication, robust access control, and local threat monitoring on edge nodes (Gupta, 2024; Siidorow, 2024).

By implementing consistent security policies across cloud and edge layers, mobile banking providers can ensure end-to-end protection of sensitive financial data while maintaining optimal performance.

5.6 Regulatory Compliance and Privacy by Design
Regulatory requirements, such as GDPR, PSD2, and local banking regulations, are shaping mobile banking security strategies. Mobile applications must adhere to strict data protection and privacy standards, which include minimizing data collection, secure storage, and providing transparency to users (Fazil et al., 2025).

Privacy by design—integrating privacy considerations into every stage of application development—is becoming a standard approach. This ensures that security measures are not merely reactive but are embedded into the architecture, reducing the likelihood of breaches and regulatory penalties (Tyagi, 2025; Javed et al., 2021).

5.7 Future Research Directions
Future research in mobile banking security is expected to focus on:

1. AI-Enhanced Threat Intelligence: Leveraging advanced AI models to predict and prevent sophisticated attacks.
2. Secure Edge Computing: Developing lightweight, secure computation on mobile and edge devices to minimize exposure.
3. Adaptive Authentication: Dynamic, behavior-aware authentication mechanisms that balance security and usability.
4. Quantum-Resistant Cryptography: Preparing for future quantum computing threats that could compromise current encryption standards.
5. Cross-Platform Security: Ensuring consistent security across mobile, web, and third-party integrations (Iqra Batool & Sania Kanwal, 2025; Gupta, 2024).

By addressing these research areas, mobile banking applications can remain resilient against evolving threats, protect user data, and maintain trust.

Conclusion
In conclusion, mobile banking applications have become an essential part of modern financial services, offering convenience and accessibility to users worldwide. However, this increased reliance also exposes sensitive financial and personal data to various security threats. This state-of-the-art review highlights the diverse range of vulnerabilities in mobile banking applications, including authentication weaknesses, insecure data storage, improper session management, and susceptibility to malware and phishing attacks. It also emphasizes the importance of systematic risk assessment frameworks, which allow organizations to identify, evaluate, and mitigate potential threats effectively. By combining insights from recent studies, developers and security professionals can implement best practices such as multi-factor authentication, secure coding techniques, regular penetration testing, and continuous monitoring. Furthermore, emerging approaches like AI-driven threat detection, blockchain-based transaction validation, and privacy-preserving cryptographic protocols offer promising directions for enhancing security in mobile banking. Overall, addressing both technical vulnerabilities and human factors is crucial to ensuring a resilient and trustworthy mobile banking ecosystem. Continued research, adherence to security standards, and proactive risk management remain pivotal in safeguarding financial applications against evolving cyber threats.

REFERENCES

[1] [Batool, I., & Kanwal, S. (2025). Serverless Edge Computing: A          Taxonomy, Systematic Literature Review, Current Trends and Research Challenges. arXiv:2502.15775 [cs.NI]. https://arxiv.org/abs/2502.15775

[2] Cao, K., Liu, Y., Meng, G., & Sun, Q. (2020). An Overview on Edge Computing Research. IEEE Access, 8, 85714–85728. https://doi.org/10.1109/ACCESS.2020.2991734

[3] Dong, Y., Bai, J., & Chen, X. (2020). A Review of Edge Computing Nodes Based on the Internet of Things. In Proceedings of the 5th International Conference on Internet of Things, Big Data and Security (IoTBDS) (pp. 313–320). https://doi.org/10.5220/0009407003130320

[4]  Fazil, A. W., Ghairat, A., & Kohistani, A. J. (2025). Advancing Web-Based Information Systems Performance via Edge Computing: A Comprehensive Systematic Review. GAME, 2(4), 1–20. https://doi.org/10.29103/game.v2i4.24189

[5]  Gupta, R., Danilov, C., Eckhardt, J., Bernard, K., & Nahrstedt, K. (2025). Characterizing Container Performance in Edge Computing. In Proceedings of the ACM SIGCOMM 2025 Posters and Demos (pp. 94–96). https://doi.org/10.1145/3744969.3748438

[6]  OWASP Foundation. (2023). OWASP Mobile Top 10: The Ten Most Critical Mobile Security Risks. OWASP Project Documentation. https://owasp.org/www-project-mobile-top-10/Conference Name:ACM Woodstock conference

[7]  Alzubaidi, L., Fadhel, M. A., Al-Shamma, O., Zhang, J., & Duan, Y. (2023). A Survey on Mobile Banking Security: Threats, Vulnerabilities, and Countermeasures. IEEE Access, 11, 28745–28762. https://doi.org/10.1109/ACCESS.2023.3254187

[8]  Zhang, Y., Liu, H., Wang, X., & Chen, M. (2024). AI-Based Fraud Detection and Risk Assessment in Mobile Banking Systems. Computers & Security, 134, 103479. https://doi.org/10.1016/j.cose.2023.103479

The post A State-of-the-Art Review of Security Vulnerabilities and Risk Assessment Approaches in Mobile Banking Applications appeared first on Mobile USTP MKL.

Goals

As the Key Goals I identified some Basic Functionality I wanted to have completed at the end of the Semester:

• Help people to store their own data on their own systems
• Develop a functional App with Ionic and Angular
• Build a good foundation that could be expanded with other features later

Progress

During development, I encountered some setbacks which slowed down the process slightly. However, I fundamentally achieved everything I set out to do. I developed and implemented a really good RESTful backend foundation that can be used to build future features on top of, and it was designed with expansion in mind. Furthermore, I developed a coherent design language for my Ionic frontend application.

Features

The fundamental concept of my app is creating and tracking workouts. This is achieved as follows:

First, you can create a template in the Workout section. Then you can assign a title and description with a specific character limit. Then you can plan different exercises, each with a distinct weight and number of repetitions. In future, I also want to include options for choosing the length or time of a single exercise instead of the weight or reps. Once you have created the template, you can save or discard it, or delete it completely.

Once you have created the different templates, you can assign them to different dates in the Calendar tab. This tab is currently under construction and will be improved for better readability in the future, but it is like this for reasons of time constraints. Here, you can select a template and a workout, which will then be added to the calendar on this date.

Once you have created the training, you can go to the ‘Home’ page to see when your next training session is scheduled and to start it. While started you can edit the done weight and reps and save it after you are done with the exercise:

Conclusion:

I was surprised by how much effort it took to get to this point. Building something from the ground up with many future features in mind broadened the scope of the initial project setup, and this wasn’t easy for me. The backend in particular took some time because I wasn’t very familiar with the framework and the concept as a whole. Setting up everything in Docker containers and making them communicate with each other also took some time, but it wasn’t as challenging as the other parts because I have some experience with this technology already. So what have I completed from my inital Goals and what have i learned? In my project description, I stated that my app should contain account creation, repetition scheduling for training sessions, and a customisable point system.

• Creating an account was not really a problem. I also enhanced the security of the application by implementing authentication via a short-lived JWT (JSON Web Token) and a refresh token that could be used to refresh the JWT and extend the active session, thereby preventing the user from having to log in constantly.
• During the development process, I questioned the point of having recurring training sessions, as I prefer to plan my training in advance, but my schedule changes every week. I would also like to be able to adapt the template or adjust the weights or repetitions according to my performance in the previous session. As this feature didn’t make much sense, I changed it so that I can create training sessions by clicking on the calendar.
• Sadly, the customisable point system fell a little short due to my limited time, but I still want to implement a good statistics system in the future. I’ve also prepared everything for the factor that I can apply to each exercise to alter the ‘score weight’.

But what have I learned?
I’ve learned the hard way that planning is absolutely everything, no matter how big your project is. The database structure and the architecture of an application are important things to consider when starting a new project, and will save so much time during development. I’ve also gained a good understanding of NestJS and its use with MongoDB, although there’s still a lot more to learn.

Outlook and future Features

Not only because i want to use this application for myself in the future but also because i really had fun programming it i have many Ideas for the next features.

• Firstly, I would like to create a better calendar page for creating new workouts and viewing a weekly overview of future training sessions.
• Another important feature would be the ability to reset your own password and confirm your email address.
• I want to implement scoring and analytics for my workouts to track
• I also want to add a locally connected LLM through Ollama to recommend training, exercises or tips based on completed workouts and user profiles containing all the relevant health data.
• Improve the security within the Docker Network and the instances itself

The post Gymetrics | self-hostable fitness tracker: semester one progress appeared first on Mobile USTP MKL.

This paper discusses recent developments in Simultaneous Localization and Mapping (SLAM) combined with the use of Artificial Intelligence (AI). SLAM makes it possible for robots to build maps of unknown environments while tracking their position, but with traditional methods robots often struggle in dynamic or unstructured settings due to unclear or moving objects. Recent advances in AI and its integration into SLAM address these issues by improving feature extraction, predictive modeling, and adaptability. Convolutional and Graph Convolutional Networks enhance robustness and scalability, while transformer architectures enable efficient trajectory planning. Obstacle detection and avoidance in real-world scenarios are further reinforced by deep reinforcement learning. AI-driven innovations also introduce multi-modal sensor fusion, semantic mapping, enhanced loop closure detection, and collaborative multi-agent frameworks. Comparative studies reveal that AI-enhanced SLAM shows a higher accuracy and robustness across varied scenarios.

The post State of the Art of AI-Enhanced SLAM appeared first on Mobile USTP MKL.

With the enforcement of the European Accessibility Act (EAA), digital accessibility has shifted for many companies from just a recommendation to a necessity. This article provides an overview of the current state of web accessibility grounded in Web Content Accessibility Guidelines (WCAG) 2.1 and 2.2, the gold standard for the EAA. The article lists the core principles and conformance levels, examines the limitations of current testing methodologies, and identifies weaknesses. Specifically, it addresses the reliance on human evaluation and the related expert problem due to automated tools’ inability to detect more than 20 to 50 percent of violations. The article also reviews modern implementation strategies, such as integrating testing engines like Axe-Core into CI/CD pipelines, and addresses the lack of inherent accessibility support in modern front-end frameworks. Finally, the paper offers an outlook on the evolving WCAG 3.0 standard and explores the transformative potential of AI and large language models (LLMs) in assisting developers and improving assistive technologies.

1. Introduction

The topic of accessibility in modern web technologies is more relevant than ever. With the European Accessibility Act (EAA) already in effect, many companies must take action [4]. The goal is for every company with more than ten employees and a turnover of over two million euros to comply with these rules. This ensures that the web is accessible to everyone. However, there are many challenges to implementing web accessibility after a website or web app has been developed; it can be very costly and time-consuming to do so. To address these challenges, this article analyzes the current landscape of web accessibility under WCAG 2.2, specifically identifying weaknesses in testing methodologies and the reliance on human evaluation. Furthermore, it outlines future advancements by exploring the flexible WCAG 3.0 standard and the transformative potential of AI and Large Language Models in development.

2. Web Accessibility Definition

As stated by Petrie, Savva, and Power (2015), accessibility on the web is a set of rules that, when followed, ensures that all people, particularly those with disabilities and the elderly, can use websites in a variety of contexts, including mainstream and assistive technologies [7].

2.1 WCAG

A cornerstone in the realm of accessibility are the Web Content Accessibility Guidelines (WCAG). Developed by the World Wide Web Consortium (W3C), these guidelines provide a standardized procedure for creating accessible internet offerings.

Over the years, the standards have been reworked several times. The current standard required by the EU in the EAA is WCAG 2.1 [8]. For uniformity purposes, this article focuses on the more current WCAG 2.2. This standard relies on four base principles that are summarized by the acronym “POUR” and contain the following points:

• Perceivable: The information and user interface components must be presented to users in a way that they can perceive.
• Operable: The user must be able to handle the user interface components and the navigation.
• Understandable: The information and the handling of the user interface must be understandable.
• Robust: The content must be robust enough that it can be reliably interpreted by a wide variety of user agents, including assistive technologies.[8]

2.2 The WCAG 2.2 Guidelines in Detail

To fully grasp the topic and its inherent challenges, it is essential to understand the core principles. To ensure a positive experience for every user, evaluations should use specific Success Criteria. This creates a repeatable test to verify that a product conforms to WCAG rules [13]. The key criteria for each principle are as follows:

2.2.1 Perceivable

• Text Alternatives: Requires providing text alternatives for any non-text content (such as images, icons, or input elements) so that it can be transformed into other forms people need, such as large print, Braille, speech, or symbols.
• Time-based Media: Requires providing alternatives for time-based media. This includes providing captions, audio descriptions, and potentially sign language interpretation.
• Adaptable: Content must be created in a way that allows it to be presented in different formats without losing information or structure. This can be achieved with different layout options, for example. Ensuring that the information and structure can be programmatically determined by assistive technology is key.
• Distinguishable: This ensures that it is possible for every user to distinguish the different elements of a digital product from others. That could be achieved by a good contrast ratio, providing the controls attribute for audio elements, and enabling users to change the size of displayed text.

2.2.2 Operable

• Keyboard Accessible: All functionality must be available from a keyboard interface. Providing universal keyboard input is crucial because no other input form offers the same flexibility or is universally supported by people with different disabilities.
• Enough Time: Users must be provided enough time to read and use content, since many users with disabilities require more time to respond, read, or use assistive technology. This can be a problem with automatically disappearing popups or toast messages.
• Seizures and Physical Reactions: Content must be designed to avoid causing seizures or physical reactions, primarily by restricting flashing visual content.
• Navigable: Users must have ways to help them navigate, find content, and determine where they are. This includes ensuring logical focus order, clearly defined headings and labels, and the ability to bypass blocks of repeated content. A good test for this would be trying to navigate a webpage with just the tab key.
• Input Modalities: This requires making the functionality operable through various inputs beyond the keyboard, such as touch, a stylus, or a mouse pointer. This includes providing alternatives for complex pointer gestures, such as drag-and-drop, and ensuring that target sizes are large enough for touch input.

2.2.3 Understandable

• Readable: This aims to ensure that text can be read by screen readers and other assistive technologies.
• Predictable: This guideline focuses on achieving a consistent, repeatable way to interact with webpages.
• Input Assistance: Must help users avoid and correct mistakes. Since people with disabilities may have more difficulty creating or detecting input errors, this guideline requires effective error identification, providing instructions and labels, and error prevention features, particularly for legal or financial transactions. Logical error messages and suggestive labels are a good way to start.

2.2.4 Robust

• Compatible: Due to the rapid changes in modern technology, developers of assistive technologies are struggling to keep up. Thus, the primary focus of this guideline is maximizing compatibility with current and future user agents.
• Technical Compliance: Robustness means ensuring content adheres to conventions so that assistive technologies can reliably recognize and interact with elements.[15]

3. Compliance via WCAG 2.2

Compliance via Web Content Accessibility Guidelines is determined by satisfying its success criteria, which were explained previously [12].

3.1 Conformance Level

To achieve full compliance, the content must meet five conformance requirements. It is possible to conform at different levels and in different categories. However, to fulfill each level, all associated rules must be applied.

• Level A: Contains, for example, all necessary labels and tags that can be associated with the HTML code. No conformance to WCAG is possible without at least satisfying all the Level A success criteria.
• Level AA: The content must satisfy all the Level A and Level AA success criteria. This is the industry standard and the minimum requirement for a WCAG-compliant webpage. It also meets the standards of the EAA because they are based on WCAG Level AA [4].
• Level AAA: All content must satisfy the Level A, Level AA, and Level AAA success criteria. One example of a required service is providing sign language interpretation for all videos and audio content.

For any of these levels, conformance can alternatively be achieved if a conforming alternate version is provided [12].

3.2 Testing Procedures

While accessibility testing is frequently conducted manually through human inspection [1], standardized automated tools also play a valuable role. However, human evaluation remains the best practice, as automation alone is often insufficient. Although automated tests offer significant advantages regarding scalability and integration into the development lifecycle, they frequently fail to detect crucial compliance issues [14]. Consequently, directives such as the European Accessibility Act explicitly require human involvement for validation [3].

4. Challenges in the Current Guidelines

The current Web Content Accessibility Guidelines pose several significant challenges related to their objective testability, consistent implementation, and overall scope.

The fundamental issue with the reliability of the WCAG 2.0 guidelines is its review and testing process. Although the process is partially automated, it still relies heavily on human judgment [1].

The current rules define reliable human testing as when 80 percent of evaluators agree on a website’s compliance. However, empirical studies have shown that approximately 50 percent of WCAG 2.0 success criteria fail to reach this threshold, even when evaluated by accessibility experts. Another issue is the high level of expertise needed to assess conformity [1].

Another significant challenge in passing some tests is the binary approach of WCAG 2.0. Evaluators can only give a pass or fail for each level of conformance [10].

5. The Future Standard: WCAG 3.0

To address these issues, the W3C began developing a new standard called WCAG 3.0. Although it has not yet been released, the first working draft was published in September 2025. The finished guidelines are expected to be released in a few years [5].

5.1 Shift in Philosophy

The new standard aims to move away from rigid rule sets and the traditional “pass/fail” paradigm. Instead, it focuses on a user-centered approach that prioritizes core functionality and the specific needs of individuals using assistive technology. Additionally, the guidelines are intended to support a wider range of disabilities by providing more personalized and adaptable experiences. This flexibility helps it remain relevant as technology evolves over time [11].

Moreover, the standard is designed to regulate not only web applications but also software in general, including smartphone apps and desktop programs. The guidelines cover accessibility across a variety of hardware, ranging from desktops, laptops, and tablets to wearables and Internet of Things (IoT) devices. They also apply to diverse content types, such as static, dynamic, interactive, and streaming media, as well as virtual and augmented reality [11].

WCAG 3.0 intends to build on the current foundations and incorporate accessibility overlays. These overlays can make websites more accessible without redoing previous work, thereby simplifying implementation [10]. However, it is important to acknowledge that this technological approach under the current WCAG 2.2 faces significant criticism within the community. Many experts argue that it does not replace the necessity of intrinsic accessible design [6].

5.2 New Scoring System

The new conformance model will fundamentally change how things are evaluated, building upon similar requirements to the current norm. Since the ruleset and evaluation criteria are still being developed, only a few details are known about how it will work.

The proposed model for WCAG 3.0 conformance is based on three main components:

• Foundational Requirements: These constitute the most basic level of conformance.
• Supplemental Requirements: These are used, alongside Assertions, to define and meet higher levels of conformance.
• Assertions: These are defined as a formal claim of fact, attributed to a person or organization, regarding documented procedures practiced in the development and maintenance of the content or product to improve accessibility.

The main differences and similarities can be seen in Table 1.

Table 1: Comparison of Conformance: WCAG 2.2 vs. WCAG 3.0

Sources: [5, 10, 12]

6. State-of-the-Art Implementation

6.1 Modern Tooling and CI/CD

To ensure inclusivity from the beginning, the best practice is to include automated tests in CI/CD processes. These approaches can identify common issues early on, provide continuous feedback, and are easily scalable [9].

Ci-Accessibility stated that there are many accessibility tools available and suitable for integration into automated testing frameworks:

• Deque Systems’ Axe-Core CLI: This open-source accessibility testing engine is designed to work across modern web techniques and supports WCAG 2.0, 2.1, and 2.2 levels A, AA, and AAA. Axe was found to be among the easiest tools to integrate into a CI/CD workflow, such as using GitHub Actions. It provides good descriptions, precise locations for errors, and links to further documentation, making it highly valuable.
• Squiz Labs’ HTML_CodeSniffer: This tool checks HTML documents for accessibility violations based on rule-sets encompassing the three conformance levels of WCAG 2.2. It can be integrated into a CI pipeline, although it may require additional configuration and coding compared to tools like Axe.
• IBM’s Equal Access Accessibility Checker: This tool consists of open-source components that validate web code against accessibility concerns, complying with WCAG 2.2 levels A and AA. Along with Axe, it was noted as one of the easiest tools to integrate into a CI/CD pipeline.

A comparative study on integrating tools into a GitHub Actions CI/CD workflow found that Axe demonstrated the best overall performance in detecting WCAG violations among the tools tested [9].

All of these options can also be used on the client side to provide easy verification of finished products or to support human evaluations. Despite the advancements in tool integration, automated accessibility tools have significant limitations, underscoring why human expertise, as discussed before, remains critical to comprehensive success. Automated tools can only detect a fraction of Web Accessibility guideline violations. A study found that selected open-source evaluation tools detected, on average, approximately 20 percent of all errors present on a given web page. This falls within the expected range, as accessibility experts note that only 20 percent to 50 percent of all accessibility issues can be automatically detected. Automated tools can produce false positives or false negatives, further reducing the accuracy of the results [9].

6.2 Role of Modern Frontend Frameworks

While specialized tools (often integrated as linters or automated testing components) are essential for checking WCAG conformance, modern frontend frameworks themselves currently provide minimal inherent accessibility support during the development process, as shown in the study of Support-Webframeworks. The testing of modern front-end frameworks (Angular, React, and Vue) was an empirical study designed to evaluate the extent to which they support developers with automated accessibility features during the development process. The study focused on creating inaccessible web applications on purpose and observing whether the frameworks generated internal feedback about the violations. Each framework was configured using its default settings at installation. All development was carried out in Visual Studio Code. The study concluded that the three frameworks offered almost no feedback regarding accessibility violations. React was the only framework able to detect an issue, generating a single warning for the WCAG 1.1.1 Non-text Content violation. This violation occurred due to the absence of a label for non-text content.

The current draft of WCAG 3.0 acknowledges this issue and aims to address it through a holistic, technology-agnostic approach [11].

6.3 Role of Artificial Intelligence

In the study of AI, AI coding assistants, such as GitHub Copilot, are being explored for their potential in creating more accessible user interfaces. A prototype Visual Studio Code extension has been introduced that integrates an LLM to help developers identify and resolve accessibility issues. Similarly, the CodeA11y GitHub Copilot Extension has been developed to make AI coding assistants useful for accessible web development. The most frequent use case leverages LLMs to automatically generate high-quality alternative text for complex web images or labels for different actions in the HTML code. AI-based techniques can also significantly reduce the need for manual checks in accessibility testing by integrating seamlessly into automated environments.

AI can also be integrated into assistive technologies and conversational agents to offer new opportunities for improving accessibility. For instance, AI-assisted speech recognition and conversational AI have demonstrated the ability to overcome the limitations of traditional screen readers, thereby increasing the inclusivity of web resources for blind and visually impaired users [2].

7. Conclusion and Outlook

As of now, the current WCAG 2.2 standard has many weaknesses due to rapid changes in modern technologies, but it remains a very important milestone in making the digital world accessible for everyone. The testability of some applications is slowed down or becomes impossible when human evaluators disagree. Additionally, the binary ‘pass or fail’ nature of the criteria stated, often leads to failed tests. The future of digital accessibility lies in the W3C Accessibility Guidelines (WCAG) 3.0. This new approach, which is currently under development, is a significant evolution toward a framework that is more user-centric, flexible, and not dependent on a specific technology. It tries to address issues with the scoring system and enables better support from frontend web frameworks and AI-driven CI/CD tools, to warn developers from non-compliant code. Complementing this evolution, AI coding assistants and LLMs are becoming essential for automating tasks like alt-text generation, while AI-integrated assistive technologies are overcoming screen reader limitations to further enhance inclusivity for visually impaired users.

References

[1] Brajnik, G., Yesilada, Y., & Harper, S. (2010). Testability and validity of WCAG 2.0: the expertise effect. In Proceedings of the 12th international ACM SIGACCESS conference on computers and accessibility (p. 43–50). New York, NY, USA: Association for Computing Machinery. https://doi.org/10.1145/1878803.1878813

[2] Campoverde-Molina, M., & Luján-Mora, S. (2025). Artificial intelligence in web accessibility: A systematic mapping study. Computer Standards & Interfaces, 96, 104055. https://doi.org/10.1016/j.csi.2025.104055

[3] European Commission. (2025). Web accessibility shaping europe’s digital future. Retrieved 2025-12-03, from https://digital-strategy.ec.europa.eu/en/policies/web-accessibility

[4] European Union. (2019). Richtlinie (EU) 2019/882 des europäischen parlaments und des rates vom 17. april 2019 über die barrierefreiheitsanforderungen für produkte und dienstleistungen (Vol. 151). Retrieved 2025-12-03, from http://data.europa.eu/eli/dir/2019/882/oj

[5] Initiative (WAI), W. W. A. (2025). WCAG 3 introduction. Retrieved 2025-12-04, from https://www.w3.org/WAI/standards-guidelines/wcag/wcag3-intro/

[6] Makati, T., Tigwell, G. W., & Shinohara, K. (2024). The promise and pitfalls of web accessibility overlays for blind and low vision users. In Proceedings of the 26th international ACM SIGACCESS conference on computers and accessibility (pp. 1–12). New York, NY, USA: Association for Computing Machinery. https://doi.org/10.1145/3663548.3675650

[7] Petrie, H., Savva, A., & Power, C. (2015). Towards a unified definition of web accessibility. In Proceedings of the 12th international web for all conference (pp. 1–13). Association for Computing Machinery. https://doi.org/10.1145/2745555.2746653

[8] Routledge Open Research. (2022). The EU accessibility act and web. Retrieved 2025-12-03, from https://routledgeopenresearch.org/articles/1-30

[9] Sane, P. (2021). A brief survey of current software engineering practices in continuous integration and automated accessibility testing. In 2021 sixth international conference on wireless communications, signal processing and networking (wispnet) (p. 130-134). https://doi.org/10.1109/WiSPNET51692.2021.9419464

[10] Sikder, A. S. (2023). The evolution of web accessibility guidelines: A comparative analysis of WCAG 2.0 and WCAG 3.0 in ensuring inclusivity on the web. International Journal of Information Science and Technology, 1(1), 170–185. https://doi.org/10.70774/ijist.v1i1.18

[11] W3C. (2025). W3C accessibility guidelines (WCAG) 3.0. Retrieved 2025-12-04, from https://www.w3.org/TR/wcag-3.0/

[12] W3C Web Accessibility Initiative (WAI). (2025a). Understanding conformance. Retrieved 2025-12-03, from https://www.w3.org/WAI/WCAG22/Understanding/conformance

[13] W3C Web Accessibility Initiative (WAI). (2025b). Understanding techniques for WCAG 2.2 success criteria. Retrieved 2025-12-03, from https://www.w3.org/WAI/WCAG22/Understanding/understanding-techniques

[14] W3C Web Accessibility Initiative (WAI). (2025c). Understanding test rules for WCAG 2.2 success criteria. Retrieved 2025-12-03, from https://www.w3.org/WAI/WCAG22/Understanding/understanding-act-rules

[15] W3C Web Accessibility Initiative (WAI). (2025d). Understanding WCAG 2.2. Retrieved 2025-12-03, from https://www.w3.org/WAI/WCAG22/Understanding/

The post SOTA | Modern Web Accessibility appeared first on Mobile USTP MKL.