My approach: patch what’s broken, intercept at the right layer, and add the missing primitives (offline queue, PDF workflows, secure auth). I work across UIKit/SwiftUI, WKWebView, PDFKit, React, and glue code—end to end.
Senior‑level interventions that make legacy systems usable on iOS without rewriting them.
WKUserScript (center dialogs, zoom‑safe)
// Inject CSS at document-start to patch layout issues safely.
let patchCSS = \"\\"\\"
html, body { overscroll-behavior: contain; }
.modal-dialog { position: fixed !important; inset: 50% auto auto 50% !important; transform: translate(-50%, -50%) !important; }
img,canvas { max-width: 100%; height: auto; }
@media (max-width: 1024px){ body { -webkit-text-size-adjust: 100%; } }
\\"\\"\
let src = "var s=document.createElement('style');s.innerHTML=\(patchCSS.debugDescription);document.documentElement.appendChild(s);"
let userScript = WKUserScript(source: src, injectionTime: .atDocumentStart, forMainFrameOnly: true)
webView.configuration.userContentController.addUserScript(userScript)
/* Center dialogs regardless of pan/zoom */
.modal-dialog{ position:fixed!important; inset:50% auto auto 50%!important; transform:translate(-50%,-50%)!important; }
/* Respect mobile zoom and prevent clipped content */
html,body{ overscroll-behavior:contain; }
@media (max-width:1024px){ body{-webkit-text-size-adjust:100%} }
func webView(_ webView: WKWebView, decidePolicyFor nav: WKNavigationAction,
decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {
if nav.navigationType == .linkActivated, let url = nav.request.url {
if url.host?.contains("login") == true || url.scheme == "itms-apps" {
presentSafari(for: url) // keep main WebView clean
return decisionHandler(.cancel)
}
}
decisionHandler(.allow)
}
import PDFKit
func presentPDF(data: Data, title: String){
let pdf = PDFDocument(data: data)
let vc = UIViewController()
let view = PDFView(frame: .zero)
view.document = pdf
view.autoScales = true
vc.view = view
vc.title = title
navigationController?.pushViewController(vc, animated: true)
}
struct PendingJob: Codable {
enum Kind: String, Codable { case formPost, fileUpload, note }
var id: UUID = .init()
var kind: Kind
var endpoint: URL
var payload: Data
var createdAt: Date = .init()
}
final class OfflineQueue {
private(set) var jobs:[PendingJob] = []
func enqueue(_ job: PendingJob){ jobs.append(job); persist() }
func flushIfOnline(){ /* reachability -> replay with backoff; verify 2xx; remove */ }
private func persist(){ /* write to disk */ }
}
iOS‑first polish: haptics, safe areas, keyboard avoidance, accessible contrast.
I build the other half too: React micro-UIs, macOS utilities, build tooling, and pipelines.
These clips highlight the internal app I built for my team. What started as a way to wrap existing web tools on iOS evolved into a fully custom hybrid app: a polished, stable environment that fixed framework-level issues on iPad and added entirely new functionality. From a branded weekly schedule builder to a built-in document editor with signing and export, these demos show it’s more than just a wrapper — it’s a true app experience.
Minimal, focused snippets. Full project available on request.
final class WebController: UIViewController, WKNavigationDelegate {
private lazy var webView: WKWebView = {
let conf = WKWebViewConfiguration()
conf.defaultWebpagePreferences.allowsContentJavaScript = true
let w = WKWebView(frame: .zero, configuration: conf)
w.navigationDelegate = self
return w
}()
override func viewDidLoad() {
super.viewDidLoad()
view.addSubview(webView)
webView.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
webView.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor),
webView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
webView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
webView.bottomAnchor.constraint(equalTo: view.bottomAnchor)
])
loadHome()
}
private func loadHome(){
let req = URLRequest(url: URL(string:"https://example-legacy-app")!)
webView.load(req)
}
}
struct ShellView: View {
@State private var selected = 0
var body: some View {
VStack(spacing:0){
Picker("", selection: $selected){
Text("Home").tag(0)
Text("Docs").tag(1)
Text("Queue").tag(2)
}
.pickerStyle(.segmented)
.padding(.horizontal)
Group{
switch selected {
case 0: WebContainer(url: URL(string:"https://example")!)
case 1: PDFListView()
default: QueueView()
}
}
}
}
}
export default function FileViewer({ file }){
const [overlays, setOverlays] = useState([]);
useEffect(() => { /* load file, hydrate overlays */ }, [file]);
return (
{overlays.map(o => (
{o.text}
))}
);
}
My current experience focuses on running smaller local models for experimentation and rapid prototyping. These have been ideal for my hardware and allow me to quickly test and validate workflows. For larger-scale environments or production workloads, I can adapt these approaches to API-driven or hosted LLM solutions as needed.
For some workflows, full-blown LLMs are unnecessary. I’ve designed deterministic systems using curated phrase banks and rule-based transforms that produce fast, consistent, and “AI-like” results — without the latency, cost, or unpredictability of machine learning.
type Mode = "llm" | "deterministic";
const mode: Mode = env.USE_LLM ? "llm" : "deterministic";
export async function formatNote(input: string){
if(mode === "llm"){
return await ollamaSummarize(input);
} else {
return deterministicTemplate(input); // instant, rule-based output
}
}
I’m happy to deliver a sample build or complete a technical challenge to show what I can do.
Email: mo.ali91942@gmail.com · Business: safenetoperations@gmail.com · Location: California · Full‑time or contract.