Native macOS Swift/AppKit Engineer
“Ehsan was truly one of the best people I've worked with on Upwork.”
May–Aug 2026
iOS AI Development
& On-Device Intelligence for Startups That Ship.
I build production iOS and macOS apps for startups—specializing in Swift 6 architecture, privacy-first products, and on-device intelligence with Core ML and Apple Foundation Models.
From the lab · Pre-alpha open system
Meet Blossom OS.
A local-first, agent-native Linux desktop exploring how AI can help while explicit approval, narrow capabilities, and inspectable execution keep people in control.
Explore Blossom OSLOCAL-FIRST · AGENT-NATIVE · OPEN SOURCE
What is 3Nsofts?
3Nsofts is an Apple-platform development studio led by Ehsan Azish. We build production Swift applications and provide focused technical diagnostics, architecture audits, fixed-scope MVP development, and privacy-first on-device AI integration for iOS, iPadOS, and macOS.
29 catalogue · 15 live on the App Store
Portfolio status
5 days
Audit delivery
Local-first
Privacy architecture
No API fees
For on-device inference
BUILT ON
Technical deep dive: Swift 6 & AI integration guide series · iOS AI Development Guide
We follow Apple standards for privacy, AI, and release quality. See Core ML, Foundation Models, App Privacy Details, and App Store Review Guidelines.
Proof in production
App Store products, production systems, and verified client feedback. See the problem, the architecture, and the result—not just a list of technologies.
The Company App
B2B Operations Platform · iOS & iPadOS
★★★★★ 5.0 · Live on App Store
Problem
Business owners running operations through messaging threads, paper trails, and approval bottlenecks. Decisions wait. Owners pay for tools their teams don't even own.
System
Owner-controlled CloudKit architecture. The owner holds the data and the subscription, while team members join free under role-based permissions. Built on an ISO 27001-aligned operations model covering warehouse, sales, and dispatch.
Outcome
Approvals and team communication move from days to minutes. Paper-based bureaucracy disappears. The owner keeps control of every record on their private iCloud.
- →One subscription covers the entire team
- →Role-based access for warehouse, sales, dispatch, CRM
- →Owner-owned data, never on a third-party server
- →Notification-driven approvals replace email threads
Client Reviews
12 completed contracts · 5.0 average rating on Upwork
FORGE SUITE · 5 NATIVE APPS · LOCAL-FIRST
Five professional Mac apps.One native suite.
Forge Suite brings together focused tools for 3D assets, spreadsheets, documents, photos, and video. Built with Swift and SwiftUI. Private, offline, with free workflows and clearly explained optional upgrades.
Who This Is For
I work with specific types of teams and projects. The best results come from clear fit. Most clients are building something that requires serious iOS engineering: not a website wrapped in a WebView, but a native app with local persistence, CloudKit sync, or on-device AI. If you are a funded startup, a privacy-first product team, or a team that has outgrown a fragile prototype and needs production-grade architecture, you are likely a good fit.
- Ideal for
- Funded startups building their first iOS app
- Privacy-first products needing on-device processing
- Complex data-driven apps requiring solid architecture
- Teams needing production-grade architecture from day one
- Not for
- Marketing websites or simple content apps
- Unbounded build requests without a defined scope
- Template customization or white-label solutions
- Projects requiring 24/7 support or immediate turnaround
Packaged Projects
Four clear engagements, each with a defined output. Start with a half-day diagnostic for one focused technical question, then move to an architecture audit, production MVP sprint, or on-device AI integration when the scope is ready. Any requested change outside the agreed scope is documented and priced before work begins.
Half-Day Technical Diagnostic
A focused review for one iOS, macOS, architecture, performance, sync, App Store, or on-device AI question. Share the relevant context, work through it in a focused call, and leave with written findings and prioritized next steps.
Fixed range
$400–$800
Half day · Written notes plus a call
→ A useful answer before a larger commitment
iOS Architecture Audit
A structured 5-day async review of your iOS codebase covering MVVM/TCA pattern consistency, dependency injection, SwiftUI lifecycle issues, and Core ML readiness. Delivered as a prioritized roadmap with specific file-level recommendations. Teams typically surface 8–12 actionable architecture issues before their next App Store submission, reducing post-launch crash rates and compressing the next build cycle by weeks. The audit includes an on-device AI readiness assessment: whether your data model and inference pipeline are structured to support Core ML or Apple Foundation Models integration without a full rewrite.
Starting from
$1,500
5 days · Async-first, one live session
→ Prioritized technical roadmap
iOS MVP Sprint
A 4–5 week sprint delivering a SwiftUI codebase with local persistence, CloudKit or custom API sync, core screen navigation, and a TestFlight-ready binary. The sprint covers one primary data model end-to-end with production-grade architecture from day one, not a throwaway prototype. Fixed price from $9,000 with no hourly billing. Teams typically reach App Store submission within 4–8 weeks of sprint delivery. If your product requires iOS AI development features such as on-device classification, smart suggestions, or local natural language processing, those can be scoped into the sprint from the start, so the AI layer is wired into the architecture rather than bolted on later.
Starting from
$9,000
4–5 weeks · Sprint-based, async collaboration
→ App Store-ready iOS/iPadOS app
On-Device AI Integration for iOS
A 3–4 week sprint integrating Core ML or Apple Foundation Models into an existing or new iOS app. Covers model selection, quantization, the Swift inference pipeline, and UI data binding. For suitable optimized models, local inference can deliver highly responsive results while avoiding third-party per-request fees. Keeping inference inputs and outputs on the device also reduces external data transfers and supports a privacy-first architecture. Performance and compliance requirements are verified against the specific product, model, and data flow.
Starting from
$5,000
3–4 weeks · Focused integration sprint
→ Production AI feature, privacy-first
Technical Writing · 150 Articles · Updated 2026
From the Lab
Production patterns, architectural trade-offs, and engineering analysis on iOS, on-device AI, and Apple platform craft. Field-tested and production-focused.
iOS Strategy10 min
iPhone Duo App Strategy: Adaptive Baseline or Duo-Specific Features?
Most apps need a strong adaptive baseline before they need Duo-only features. Use a three-level plan to separate compatibility, continuity, and genuine dual-display value.
On-Device AI9 min
iOS AI Release Readiness Beyond Unit Tests
Reliable iOS AI needs deterministic tests, dataset evaluations, tool-trajectory checks, device profiling, privacy review, and human release evidence.
Apple Intelligence8 min
Visual Intelligence for iOS App Discovery
Visual Intelligence can surface app content from a camera view or screenshot when entities, matching, privacy, and destinations are designed well.
Unfair Advantage
Why teams choose 3NSOFTS when they need reliable systems, not quick demos. The four pillars below cover the areas that matter most for iOS products that need to survive past launch: offline reliability, on-device AI performance, a SwiftUI architecture that does not collapse under new features, and code that the next engineer on your team can actually read and extend.
Local-first architecture
Your app works even when signal drops. Data saves locally first, then syncs to iCloud in the background via CloudKit. For iOS AI development projects, local-first design means the inference pipeline and the data layer are always available, with no waiting on a network round-trip before the model can run.
On-device AI
We run suitable AI workloads on the device with Core ML or Apple Foundation Models. Local inference can keep sensitive inputs out of third-party AI services, support offline features, and remove per-request model API fees. Model size, hardware, analytics, synchronization, and the rest of the product data flow are evaluated separately.
- Uses Core ML and Apple Foundation Models.
- Inference can remain available without a network connection.
- No per-request API billing from external AI providers.
SwiftUI systems design
We build SwiftUI code that scales beyond a prototype. Teams can add features without rewrites. The architecture follows a clear separation of data, business logic, and presentation layers, so integrating on-device AI features or new CloudKit-backed data models later is additive, not disruptive.
- Clear data flow and modular screen structure.
- Reusable components with predictable behavior.
- Testing support for key screens and states.
Long-term maintainability
We optimize for the next 12 months, not only for launch week. That means architecture decisions are documented as they are made, dependencies are kept minimal, and every component is written to be readable by the next iOS developer who works on the codebase, whether that is an in-house hire six months from now or a second contractor extending your iOS AI features.
- We document architecture decisions as we build.
- Dependencies stay minimal and intentional.
- Code stays readable for the next engineer on your team.
Shipped products
Built in production
Real apps on the App Store. Each one a working proof of a specific architectural decision.
Nick
Open-source macOS security suite
On-device AI · Six detection layers · Free
macOS 26+Free · Open Source
Learn more →
The Company App
Offline-first business operations
Core Data + CloudKit sync
iOSiPadOS
Learn more →
ECHO Survival AI
Fully offline AI assistant
Apple Intelligence · zero network calls
iOSOffline
Learn more →Common Questions
Plain answers to the questions founders and product teams ask before starting.
What kind of apps does 3NSOFTS build?
Production-grade iOS, iPadOS, and macOS apps that ship to the App Store and are built to last. Most engagements involve complex data workflows: multi-role CloudKit sync, offline-first persistence with Core Data, or on-device AI with Core ML or Apple Foundation Models. Past projects include B2B operations platforms, document intelligence tools, offline AI assistants, and native macOS video toolkits. We do not take on simple CRUD apps, template customizations, or quick-turnaround prototypes that prioritize speed over architecture quality.
Do you work with idea-stage startups?
Yes. The iOS MVP Sprint is designed for idea-stage startups that have defined their product problem and are ready to build. We require the core use case, target user, and primary data model to be decided before the sprint begins. The sprint delivers a TestFlight-ready binary with production-grade SwiftUI architecture, local persistence, and sync, not a throwaway prototype. Teams typically move from sprint output to App Store submission within 4-8 weeks, with an architecture that supports new features without rewrites.
What is AI-native software?
AI-native software treats the inference pipeline as a first-class architectural layer, not a feature added after launch. In practice this means the model is wired directly into the data model, the UI responds to model outputs in real time, and the app degrades gracefully if inference is unavailable. We implement this using Core ML for custom models and Apple Foundation Models for natural language tasks. The result is AI behavior that is testable, versionable, and maintainable, not a black-box API call that breaks silently.
How long does a project take?
The Half-Day Technical Diagnostic focuses on one question and includes a call plus written recommendations. The Architecture Audit delivers a prioritized roadmap in 5 business days. The iOS MVP Sprint runs 4-5 weeks, and the On-Device AI Integration sprint runs 3-4 weeks depending on model complexity and existing codebase state. Larger engagements remain fixed-scope with pricing agreed before work begins.
What is on-device AI and why does it matter?
On-device AI runs inference locally on the user’s iPhone or Mac instead of sending every request to a remote model service. For suitable features, this can reduce external data transfers, enable offline operation, improve responsiveness, and eliminate per-request model API fees. It does not make an entire app automatically compliant: analytics, synchronization, storage, consent, and every other data flow still need to be reviewed.
Start a Project
New engagements start with a short application. It helps confirm we are the right fit before we begin.
Other inquiries
For partnerships, press, or non-project inquiries: [email protected]