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.

On hot summer days, when I go out for daily errands, exercise, or leisure, and sometimes this walk is accompanied by our pet, having access to a drinking fountain becomes essential. Dehydration can quickly become a concern for both humans and animals during long walks or outdoor activities. Therefore, having a simple and accessible solution to locate nearby drinking fountains would be extremely helpful. Such a solution could enhance comfort, safety, and overall enjoyment of outdoor activities during the warm months. It would also promote responsible pet care and encourage more people to spend time outdoors without worrying about access to wate.

Idea

This idea was born from the need to make it easier for people to find public drinking fountains using simple, accessible technology. The concept involves creating a platform that allows users to access information by scanning a QR code printed on posters placed around the city. Once scanned, the user is directed to the application, which uses their current location (GPS) to identify and display the nearest drinking fountains.
The main goal of this idea is to bridge the gap between urban facilities and everyday needs — ensuring that no one, human or animal, struggles to find drinking water during hot summer days.

Implementation

To bring this idea to life, posters titled “Drinking Fountains of Vienna” (for example, District 19) are designed and placed in various locations. By scanning the QR code on the poster, users can enter the app and, based on their current location, view a list and map of nearby drinking fountains.
Each fountain entry includes details such as distance from the user, images of the location, available facilities (for humans and pets), and the exact postal address.
When a user selects a fountain, they can view more information, including images, descriptions, and navigation options. With one click on the “Get Directions” button, the app redirects the user to Google Maps, providing the easiest route to the selected fountain.

Future Development

In the future, this project can be expanded to include all districts of Vienna, and if successful, it could serve as a model for other cities as well.
Additional features could include a user review and rating section, community reports on the condition or accessibility of fountains, and even maps of seasonal or temporary fountains.
Ultimately, this project aims to evolve into an intelligent, user-centered platform that combines technology, urban design, and environmental awareness — contributing to public well-being and sustainable urban living.

Image Sources

This project is an educational university project created for the purpose of practicing and learning software development and programming skills.

The images used in this project were obtained through Google Image Search and are used solely for educational and non-commercial purposes.

The post Print2Mobile | Vienna FOUNTAINS – DISTRICT 19 appeared first on Mobile USTP MKL.