Real-Time Price tracker (iOS coding challenge)

A lightweight SwiftUI + Combine application that simulates a real-time stock price feed using a WebSocket echo server.

The app displays 25 stock symbols, generates random prices every 2 seconds, sends them through a WebSocket connection, receives the echoed values, and updates the UI in real time.

This project focuses on clean architecture, testability, reactive streams, and maintainability, rather than UI complexity.

---

📱 Screenshots

Light Mode	Dark Mode

---

🎬 Demo

---

🎯 Project Goals

The goal of this implementation was to:

• Build a clean and testable architecture
• Use SwiftUI and Combine
• Implement real-time updates via WebSocket
• Demonstrate modern iOS engineering practices
• Provide unit tests for the business logic
• Structure the project like a production-ready codebase

---

🧠 How the task was approached

The implementation followed several engineering principles.

1. Separation of concerns

Responsibilities were split across layers:

• UI
• ViewModels
• Networking
• Domain models
• Infrastructure utilities

This allows every component to be tested independently.

---

2. Protocol‑driven architecture

Networking components rely on protocol abstractions rather than concrete implementations.

Example:

WebSocketClientProtocol
WebSocketServiceProtocol

Benefits:

• dependency injection
• easier testing
• replaceable implementations

---

3. MVVM architecture

The project follows the Model--View--ViewModel architecture.

    View (SwiftUI)
            ↓
    ViewModel
            ↓
    Service Layer
            ↓
    WebSocket Client

The ViewModel owns the application state and exposes Combine publishers to the UI.

---

⚙️ Application flow

1. User presses Start
2. ViewModel opens a WebSocket connection
3. Every 2 seconds prices are generated
4. Prices are sent through the WebSocket
5. The echo server returns the message
6. The ViewModel parses the message
7. UI updates automatically through Combine

---

🏗 Architecture diagram

    +----------------------+
    |      SwiftUI View    |
    |  FeedView / Details  |
    +----------+-----------+
               |
               v
    +----------------------+\
    |  PriceFeedViewModel  |
    |   (Combine Streams)  |
    +----------+-----------+
               |
               v
    +----------------------+
    |  WebSocketService    |
    |   (Business Logic)   |
    +----------+-----------+
               |
               v
    +----------------------+
    | URLSessionWebSocket  |
    |       Client         |
    +----------------------+

---

🧰 Technologies used

Technology Purpose

---

SwiftUI UI layer Combine Reactive data streams URLSessionWebSocketTask WebSocket networking XCTest Unit testing Localization API Internationalization

---

✨ Features

Real‑time updates

Stock prices are generated every 2 seconds and propagated through the WebSocket echo server.

The UI updates automatically thanks to Combine publishers.

---

Start / Stop feed

Users can control the feed.

Stopping the feed:

• cancels the timer
• disconnects the WebSocket

---

Connection status indicator

A simple connection indicator shows WebSocket status:

• 🟢 Connected
• 🔴 Disconnected

---

Stock details screen

Selecting a stock opens a details view showing:

• symbol
• company name
• price
• price direction

---

🌍 Localization

The project includes localization support.

Resources are located in:

Resources/Localization

Example:

en.lproj/Localizable.strings
ro.lproj/Localizable.strings

SwiftUI automatically resolves localized strings:

Text("Start")

When a raw string is required:

String(localized: "Start", bundle: #bundle)

---

🔧 Extensions

Small extensions were added to keep code clean.

Examples include:

• localization helpers
• SwiftUI text helpers
• utility improvements

These reduce boilerplate and improve readability.

---

🪵 Logging

Instead of using print(), a centralized logger is used.

Benefits:

• categorized logs
• easier debugging
• production‑ready logging

Example categories:

    networking
    websocket
    viewmodel

---

❗ Error handling

Typed errors are used in the networking layer.

Example:

WebSocketError

Errors propagate through Combine publishers, allowing the ViewModel to react appropriately.

---

🧪 Testing

Unit tests validate the main logic.

Mocks isolate dependencies so tests do not require a real WebSocket connection.

---

Tested components

ViewModel

• start feed connects socket
• stop feed disconnects socket
• message parsing
• stock sorting
• error propagation

WebSocket service

• connection state updates
• message propagation
• error forwarding

Stock generator

Ensures exactly 25 symbols are produced as required.

---

📂 Project structure

    RealTimePriceTracker
    │
    ├── App
    │   ├── RealTimePriceTrackerApp.swift
    │   └── AppContainer.swift
    │
    ├── Configuration
    │   └── AppConfig.swift
    │
    ├── Core
    │   ├── Errors
    │   ├── Logging
    │   └── Localization
    │
    ├── Networking
    │   ├── Protocols
    │   ├── Clients
    │   └── Services
    │
    ├── Stocks
    │   ├── Models
    │   ├── Generators
    │   ├── ViewModels
    │   └── Views
    │
    ├── Resources
    │   └── Localization
    │
    └── Tests
        ├── ViewModelTests
        ├── ServiceTests
        └── UtilityTests
------------------------------------------------------------------------

🧩 Why this architecture

The architecture prioritizes:

• testability
• modular design
• clear separation of concerns

  Decision       Reason
  -------------- ---------------------------------------
  MVVM           Clear separation between UI and logic
  Protocols      Enables dependency injection
  Combine        Reactive UI updates
  DI Container   Clean dependency management

------------------------------------------------------------------------

🚀 Running the project

1. Open in Xcode
2. Select an iOS simulator iOS 26+ version
3. Run the app
4. Press Start to begin the feed
5. Click on any stock item to open the detail screen

---

🔮 Possible improvements

Future enhancements could include:

• animated price changes
• UI snapshot testing
• WebSocket reconnection strategy
• performance optimization for large lists
• accessibility improvements

---

📌 Summary

This project demonstrates how to build a clean, reactive iOS application using modern Apple frameworks.

Key highlights:

• SwiftUI UI layer
• Combine reactive streams
• WebSocket networking
• Protocol‑driven architecture
• Unit tested business logic
• Localization support

The result is a small but production‑style codebase designed to showcase engineering best practices.