Delivered a new fitness website today.
Designed for workouts, fitness programs, activity tracking, goals, and progress monitoring with a clean, modern, and responsive user experience.
Full-Stack Developer & Product Designer • AI Integration
7
Followers
Full-Stack Developer & Product Designer • AI Integration
Aurus Chain – Supply Chain Web Application
Built as CTO and core developer, a production-grade 3-tier supply chain platform live at aurus-chain.web.app (http://aurus-chain.web.app).
The platform connects manufacturers, distributors, and retailers through separate role-based interfaces, handling automated order workflows, real-time inventory management, and intelligent expiry tracking to reduce supply chain losses.
Built with React, TypeScript, and Firebase, featuring REST API integrations, real-time Firestore sync, role-based authentication, and a responsive dashboard deployed to production.
Architecture is extensible beyond supply chain to any 3-tier product management system.
Cross-platform mobile apps Developer | Virtual assistant
New to Contra
Cross-platform mobile apps Developer | Virtual assistant
Title: React Native Mobile App — iOS & Android From One Codebase
Price: Starting $495 (fixed-price project)
Description:
I build cross-platform mobile apps in React Native — one codebase, both iOS and Android, native performance.
What you get:
→ Full source code (yours to keep)
→ iOS build via Expo EAS
→ Android build (APK + Play Store ready)
→ API integration (REST, Firebase, Supabase, Stripe)
→ Push notifications, auth, deep linking
→ Deployment help for App Store & Play Store
Recent build: Wellix — a React Native health-tech app shipped to production.
Packages:
→ Starter (5 screens, basic auth) — $495
→ Standard (10 screens, API, notifications) — $895
→ Advanced (custom features, admin panel, multi-role) — $1,495+
BSc Software Engineering + 2.5 years shipping code. I write clean, documented, maintainable RN.
0
89
Steady lead flow without the overhead of a full-time hire.
I handle the parts of growth most founders don't have time for — CRM management, data scraping, and building qualified B2B lead lists that are actually ready to close. Plus admin/VA support and React Native app development if you need to ship something fast.
✅ 2.5+ years experience, 5★ rated
✅ Verified leads, cleaned data, no fluff
✅ Fast turnaround, daily updates
✅ First task free — see the quality before you commit
Working with clients worldwide. DM me if you're tired of chasing leads instead of closing them.
0
79
Most founders don't fail because their idea is bad.
They fail because it stays an idea.
I run AwanioAI — a product studio that builds AI apps, SaaS tools, dashboards, and automations for non-technical founders. No dev team required on your side. You bring the vision, we ship the working product in weeks.
Recent builds:
→ A booking + client app for a wellness studio
→ An internal automation that cut a founder's admin time in half
→ An MVP taken from idea to first paying users in under 3 weeks
If you've been sitting on an idea waiting for "the right technical person" — that's what we do.
Available now for new projects. Drop a comment or DM, or start at awanioai.com (http://awanioai.com) 👇
#AI #NoCode #SaaS #StartupTools #ProductStudio #FreelanceDev
0
114
Title: 10 Qualified Sales Calls Booked on Your Calendar Monthly
Price: $200/month (subscription)
Description:
I fill your calendar with 10 qualified sales calls per month — from your ICP, ready to hear your pitch.
What you get:
→ 10 booked calls/month (roughly 2-3 per week)
→ Prospects matched to your ICP (I'll build it with you in call 1)
→ Outreach via LinkedIn + cold email
→ Follow-ups handled (most calls come from follow-up #3)
→ Weekly report: outreach sent, replies, calls booked
→ No-shows are replaced free
Why me:
→ 2.5+ years booking calls for agencies, SaaS, coaches, and consultants
→ I write DMs and emails that get replies (samples on request)
→ I use your voice — not a template blast
First 5 calls free if you're not sure. If I can't deliver, you don't pay.
ShopVerse is a modern, high-performance iOS e-commerce application built using Swift (SwiftUI) and powered by Firebase as its backend infrastructure.
🏛️ System Architecture: MVVM Pattern
The application is structured around the Model-View-ViewModel (MVVM) architecture to guarantee clean separation of concerns, high maintainability, and testability across both customer and administrator workflows.
1. The Model Layer
The Model layer consists of lightweight, immutable data structures conforming to Swift's Codable and Identifiable protocols.
Product Model: Stores product details such as unique IDs, titles, descriptions, pricing, stock levels, rating summaries, and array paths for high-resolution images stored in the cloud.
Order Model: Captures transaction details including item snapshots, delivery addresses, customer identification, pricing breakdowns, and status states (Pending, Packed, Shipped, Delivered, or Cancelled).
User & Cart Models: Manage profile attributes, assigned roles (Customer or Admin), saved shipping addresses, and live active shopping cart items.
2. The View Layer
Built declaratively using SwiftUI, the View layer handles everything rendered on the screen.
Views remain strictly focused on layout rendering, animations, and capturing user interactions (e.g., button taps, pull-to-refresh gestures, and navigation transitions).
Views do not contain business logic or direct database call implementations; instead, they observe state changes exposed by their corresponding ViewModels.
3. The ViewModel Layer
ViewModels act as the reactive middleware between the data layer and UI screens.
Utilizing @MainActor and @Published properties, ViewModels manage screen-specific states (e.g., loading spinners, active product filters, and checkout step validations).
They process user input, execute asynchronous data operations via async/await, and automatically trigger UI redraws whenever data updates.
4. The Service Layer
Encapsulated as injected singletons or protocols, services manage external network interactions.
Handles low-level Firebase authentication triggers, Cloud Firestore read/write streams, image uploads to Firebase Storage, and payment gateway SDK integrations (e.g., Stripe or Apple Pay).
🔥 Firebase Backend Mechanics & Data Management
Firebase serves as the serverless engine driving ShopVerse, enabling real-time database syncing, secure authentication, and scalable media storage.
1. Authentication & Role-Based Access Control (RBAC)
Security and session management are handled through Firebase Authentication.
Multi-Provider Auth: Supports native Email/Password credentials alongside one-tap sign-ins via Apple ID and Google accounts.
Session Persistence: Authenticated tokens are stored securely in the iOS Keychain, allowing users to remain logged in across app restarts.
Role Verification: Upon successful authentication, the system queries the user's Firestore profile document to check their role attribute. If designated as admin, the app routes the user to the store management dashboard; otherwise, it presents the primary shopping portal.
2. Cloud Firestore Database Structure
Firestore operates as a real-time, NoSQL document-oriented database structured into clean top-level collections.
3. Offline Persistence & Caching
Firestore's local disk caching mechanism is enabled during app launch.
Uninterrupted Browsing: Product listings and cart states are cached locally on the device disk. If the device loses internet connection, users can still view products and manipulate their cart without app crashes or blank screens.
Background Sync: Any state changes made offline are queued locally and automatically committed to the cloud database once connectivity is restored.
4. Real-Time Data Synchronization via Snapshot Listeners
Instead of relying on traditional HTTP polling or manual screen pulls, ShopVerse utilizes Firestore addSnapshotListener connections.
Live Order Tracking: When an administrator updates an order status in the admin portal (e.g., changing an order from Processing to Shipped), a persistent WebSocket listener pushes the updated state directly to the customer's device in real time, updating the UI timeline instantly.
📱 Advanced SwiftUI Concepts & Interactive UX Patterns
To deliver a refined, native iOS user experience, ShopVerse incorporates several specialized SwiftUI and iOS framework capabilities.
1. Skeleton Loading Shimmer Effect
Rather than displaying a generic activity indicator (ProgressView), ShopVerse uses a custom shimmer modifier during initial data fetches.
Visual Continuity: Placeholder wireframe cards matching the dimensions of actual product cards are rendered instantly.
Linear Gradient Wave: An animated gradient mask sweeps horizontally across the placeholder shapes, signaling active loading while maintaining visual context.
2. Tactile Feedback & Haptic Engine Integration
To make digital interactions feel physical, ShopVerse leverages the device's Taptic Engine via UIImpactFeedbackGenerator.
Action Reinforcement: Tapping the Add to Cart button, toggling a wishlist heart icon, or confirming a checkout step triggers precise physical haptic ticks, increasing user confidence during interactions.
3. Query Debouncing using the Combine Framework
Unrestrained search fields can send dozens of unnecessary database queries while a user types, causing performance lag and inflated database read costs.
The Debounce Pattern: Utilizing Combine's .debounce(for: .milliseconds(300)) operator, search queries are held in a reactive pipeline.
Cost Optimization: Database search requests are only fired after the user pauses typing for at least 300 milliseconds, dropping all intermediate keystroke queries.
4. Administrative Data Visualization via Swift Charts
The integrated Admin Portal transforms raw Firestore sales data into actionable visual insights using Apple's native Charts framework.
Real-time Metrics: Aggregated sales figures, daily order totals, and revenue metrics are compiled into interactive bar charts and line graphs, allowing store managers to assess revenue trends dynamically.
🚨 Big reveal on the skyline! 🚨
I build custom, animated, and fully responsive portfolio websites — no templates, no shortcuts, 100% built from scratch.
✅ Custom design tailored to you
✅ Fully responsive (Mobile / Tablet / PC)
✅ Modern UI/UX with smooth animations
Ready to unveil your own standout portfolio? Let's work together 👇
https://fiverr.com/createdbysaif
0
89
🖤 Velaro — Technical Architecture
🔗 Live Website
https://saif-velaro-clothing-brand.netlify.app
📌 Overview
Velaro is a single-page application (SPA) for a fashion/clothing brand, built with React + TypeScript, bundled by Vite, and styled with Tailwind CSS. The entire UI renders on one HTML page and updates dynamically as the user scrolls, searches, or interacts with the cart — no full page reloads.
The architecture follows a standard modern frontend pattern: a single entry point boots the app, a root App component composes independent section components, and a global context manages shared state (the shopping cart) across all of them.
⚙️ Build & Tooling Layer
These files configure how the project compiles, lints, and runs — they aren't part of the visible website, but control everything behind it.
vite.config.ts — Configures Vite, the build tool/dev server. Defines how .tsx/.ts files are compiled, how the dev server runs (npm run dev), and how the production bundle is generated (npm run build).
tsconfig.json — Root TypeScript config — points to the two more specific configs below via project references.
tsconfig.app (http://tsconfig.app).json — TypeScript rules specifically for the application code in src/ (JSX handling, module resolution, strictness, the @/ path alias).
tsconfig.node.json — TypeScript rules for Node-context files (like vite.config.ts itself), since those run outside the browser.
tailwind.config.js — Configures Tailwind CSS — defines the design system (colors, spacing, fonts) and which files Tailwind scans to generate only the CSS classes actually used.
postcss.config.js — Configures PostCSS, the tool that processes Tailwind's output and applies vendor prefixing/optimization during build.
eslint.config.js — Defines linting rules — catches code-quality issues, unused variables, and React/TypeScript best-practice violations during development.
package.json — Lists all dependencies (React, Vite, Tailwind, etc.) and defines the npm scripts (dev, build, preview).
package-lock.json — Locks exact dependency versions so the build is reproducible across machines.
.gitignore — Tells Git which files/folders to exclude from version control (e.g. node_modules, dist).
index.html — The single real HTML file. Contains a root <div> that React mounts into — everything else is injected by JavaScript.
dist/ — Auto-generated production build output (plain HTML/CSS/JS) created by npm run build. This is the folder actually deployed to Netlify.
node_modules/ — Auto-generated folder holding all installed dependencies (created by npm install, never edited manually).
🚪 Application Entry & Root
src/main.tsx — The true entry point of the app. Imports React, imports App.tsx, and mounts it into the <div> inside index.html. This is the first application code that runs.
src/App.tsx — The root component. Doesn't contain page content itself — instead it imports and arranges every section component (Navbar, Hero, About, etc.) in order, and wraps everything in the CartProvider so cart state is available app-wide.
src/index.css — Global stylesheet — imports Tailwind's base/utility layers, applied once at the root so every component can use Tailwind classes.
src/vite-env.d.ts — TypeScript type declarations for Vite-specific features (like importing images/CSS as modules) — lets TypeScript understand syntax that isn't standard JavaScript.
🛒 State Management
src/cart.tsx — Implements the CartProvider, a React Context that holds global cart state (items, quantities, totals) and exposes functions to add/remove items. Any component wrapped inside it (via App.tsx) can read or update the cart without prop-drilling.
src/data.ts — Static data module — likely product listings, collection info, or other content consumed by components like FeaturedCollection and Showcase, kept separate from UI logic.
🧱 Component Layer (src/components/)
Each file is a self-contained, single-responsibility UI section. App.tsx stacks them vertically to form the full page.
Navbar.tsx — Persistent top navigation — branding, menu links, and likely triggers for search/cart.
Hero.tsx — The primary landing banner — headline, tagline, and call-to-action (e.g. "Shop Collection").
HeroCanvas.tsx — A visual/animated layer paired with Hero.tsx — likely a canvas-based or decorative background effect behind the hero text.
FeaturedCollection.tsx — Renders a curated set of products, pulling structured data from data.ts.
About.tsx — Brand-story section — static content describing the label's identity.
Lookbook.tsx — A style/editorial gallery — visually presents outfits or campaign imagery.
Showcase.tsx — An additional highlight section, likely for a specific collection, drop, or promotional content.
Testimonials.tsx — Displays customer reviews/social proof.
Newsletter.tsx — Email capture form/section for marketing signups.
SearchOverlay.tsx — A modal/overlay component for in-site product search, toggled from the Navbar.
CartDrawer.tsx — A slide-out panel UI that reads from the CartProvider (cart.tsx) to display current cart items and totals.
Footer.tsx — Bottom-of-page section — links, contact details, social icons.
🔄 How It All Connects (Data Flow)
The browser loads index.html, which pulls in the compiled JS bundle.
main.tsx runs first and mounts App.tsx into the page.
App.tsx wraps all sections in CartProvider, so cart state is shared without passing props down manually through every component.
Each section component renders independently — some are purely static/presentational (About, Footer), while others are interactive and tied into shared state (CartDrawer, SearchOverlay).
Tailwind classes used throughout every component are compiled once into index.css based on what's scanned via tailwind.config.js.
On npm run build, Vite compiles and bundles all of this into optimized static files inside dist/ — which is what gets deployed to Netlify and served to visitors.
🧠 Why This Structure Works
Separation of concerns — each component owns one visual section; layout composition happens only in App.tsx.
Centralized state — cart logic lives in one file (cart.tsx) instead of being duplicated across components.
Data/UI separation — data.ts keeps content separate from rendering logic, making it easy to update products without touching component code.
Type safety — TypeScript configs enforce consistent typing across the whole src/ folder, catching errors before runtime.
Optimized output — the dev-only tooling (Vite, Tailwind, ESLint, TS configs) never ships to production; only the final compiled dist/ bundle is deployed.