Find Your Next TypeScript Project

We are looking for an experienced React developer to fix a UI bug in an existing React application.

The issue affects the UI behavior and layout under certain conditions (details will be shared after initial contact). The codebase is already set up, and the task is focused purely on debugging and fixing the UI — no new features required.

Requirements:
- Strong experience with React.js
- Good understanding of component state and props
- Experience debugging UI/layout issues
- Ability to read and work with existing code
- Clean, maintainable fixes

Nice to Have:
- Experience with modern React (hooks)
- Familiarity with common UI libraries (Material UI, Ant Design, or similar)

Deliverables:
- UI bug fixed and verified
- No breaking changes to existing functionality

This is a small, focused task and should be quick for the right developer. Please include a brief note about your React experience when applying.

I’m building a modern e-commerce mobile application in React Native and need an experienced developer to take it from wireframes to a polished, store-ready release. The goal is a single code-base that I can ship to both iOS and Android, though I’m open to your suggestions if you have a different deployment strategy that still covers the two major platforms efficiently.

Key user flows include browsing a product catalogue, adding items to a cart, and completing checkout through an integrated payment gateway. I already have the product data and basic UI mock-ups; what I need is your React Native expertise to turn them into a fast, reliable, and visually appealing app that follows current best practices.

You’ll set up the project, connect it to my existing REST/GraphQL endpoints, handle secure authentication, and implement state management so the cart remains consistent across sessions. At hand-off I expect:

• a clean, well-documented React Native codebase
• working builds installable on both iOS and Android devices (TestFlight / APK)
• a short read-me explaining environment setup, commands, and any third-party services used

If this sounds like your wheelhouse, let’s discuss timelines and any libraries or tooling you recommend (Redux, Zustand, React Navigation, TypeScript, etc.).

Skills: Mobile App Development, iPhone, Android, eCommerce, Laravel, React Native, REST API

I run a wine-tour and private-charter business in the Margaret River region and I’m ready to hand our Instagram over to a creative who can make the feed feel both premium and effortlessly cool. You’ll have full access to a well-organised library of photos and video snippets from our tours; your job is to shape them into scroll-stopping content with a young, upbeat vibe and casual, friendly captions that still read like good English.

Each week I’ll rely on you for:
• 2 Reels edited in CapCut (trending audio, snappy transitions, on-brand colour work)
• 1 polished feed post with a caption that sounds like you’re chatting to a mate over a glass of Cabernet
• 7 stories (one per day) highlighting our daily tours and events, scheduled at peak engagement times

Payment would be monthly

We do have established brand colours, which I’ll share once we start, so your edits need to respect that palette.

If you’re fluent in Instagram’s current best practices, love experimenting with Reels, and have a portfolio that proves you can make a tourism brand look modern and premium, drop me your work and a quick note on why you’re the right fit.

Skills: Editing, Social Media Marketing, Video Production, Video Editing, Typescript, Social Media Management, Instagram Marketing, Content Strategy, Content Creation, CapCut

Summary

We have a finished UI design and a locked behavior spec (PDD).

This role is to build the UI only using SvelteKit and TypeScript.

No redesign. No product decisions. No backend changes.

When UI config tables or fields are needed, you must request them from our development team. You do not create tables or change database schema.

⸻

Role Overview

• Contract UI Builder (SvelteKit)
• Scope: UI implementation only
• Design is already complete
• Spec-driven build only
• Branch-only work (main branch is read-only)
• Target effort: 16 hours
• Hard cap: 24 hours max

Your job is to turn the provided design into working UI components exactly as specified.

⸻

Current State

• UI design is complete
• UI behavior PDD is locked
• Existing TypeScript codebase
• SvelteKit stack already in place
• Database + tables are dev-owned
• Dev team handles all schema and table creation

⸻

Required Tools

• SvelteKit
• TypeScript

Nothing else is required for this role.

⸻

What You Will Do

UI Implementation

• Build UI from provided design files
• Create chat window components
• Create message render components
• Build input + send area
• Build attachment display blocks
• Follow layout and component spec exactly
• Keep rendering deterministic
• No streaming behavior unless explicitly specified

⸻

Config & Table Dependency Handling

If the UI needs config data or tables:

• Identify exactly what fields are required
• Send clear table/field request to dev team
• Wait for dev-created tables
• Wire UI to read provided fields

You request → dev creates → you use.

⸻

What You Will NOT Do

• No redesign
• No UX changes
• No schema or table creation
• No migrations
• No backend changes
• No business logic in UI
• No retry or recovery behavior
• No framework swaps
• No commits to main branch
• No features not in design or PDD

If it is not in the design or spec — do not add it.

⸻

Deliverables

• SvelteKit UI components matching design
• Clean component structure
• Spec-accurate behavior
• List of any required config/table fields
• Basic build + run steps

No documentation = incomplete.

⸻

Definition of Done

• UI matches provided design
• UI follows PDD behavior rules
• No backend or schema changes made
• All data needs clearly listed for dev team
• Deterministic rendering confirmed
• Scope respected 100%

⸻

Contract Details

• Target time: 16 hours
• Absolute max: 24 hours
• Short-term engagement
• Work stops at delivery or 24-hour cap (whichever comes first)
• Over-cap work requires written approval

⸻

Required Skills

• SvelteKit
• TypeScript
• Component-based UI builds
• Spec-following implementation
• Git branch workflow

⸻

How to Apply

Answer directly:

Have you built a UI from a finished design and strict spec, without changing backend or database, and coordinated data needs with a dev team?

We're building a project management tool in the spirit of Trello, Notion, and Frame.io—and we're looking for a full stack developer to join us.

What you'll work on:

- A multi-tenant SaaS platform handling real-time collaboration, permissions, and complex data relationships
- Performance optimization across the stack - from database queries to frontend rendering
- Maintaining security best practices to protect user data and prevent vulnerabilities

What we're looking for:

- Strong TypeScript experience across frontend and backend
- Proficiency with React, Vite, and Supabase (or similar backend-as-a-service platforms)
- Understanding of multi-tenancy architecture patterns
- A track record of optimizing for performance and UX

Bonus points for:

- Prior experience building productivity, collaboration, or project management tools
- Familiarity with real-time features (websockets, subscriptions)

To apply: Share examples of relevant previous work—the closer to what we're building, the better.

The system is live and functional but historically grown, with structural/code-quality issues, missing validations, security gaps, and manual operational workflows.

Your mission: stabilize the platform, make the codebase maintainable, and implement reliable financial workflows for credit notes (Gutschrift) and payout preparation via SEPA pain.001 XML exports (manual upload in the client’s bank portal — no direct payment execution).

Scope / Responsibilities

1) System audit & stabilization
Understand an existing Node.js/TypeScript codebase quickly
Identify, reproduce, and fix bugs in a structured way
Improve logging, error handling, and observability
Harden APIs (validation, rate limits where needed) and secure sensitive routes (uploads, workers)
Ensure strict multi-tenant isolation (companyId/orgId) across the system

2) Credit Notes (Gutschrift) — end-to-end implementation
Implement a clean, status-driven credit note process (e.g., draft → posted)
Validation of inputs and domain rules
Auditable data flows (traceability of “why/how a credit note exists”)
Integrate into existing API/worker flows and dashboard

3) Payout preparation & SEPA export
Generate payout proposals from posted credit notes (idempotent, no duplicates)
Validate bank data (IBAN) + business rules
Create SEPA pain.001 XML export batches for bank portal upload
Track export history + statuses (exported/paid), with an MVP “mark as paid” workflow
Design for future reconciliation (optional)

Tech Stack
Node.js + TypeScript
Backend: Express / NestJS / Next.js API routes (existing system)
Validation: Zod (or similar)
Queue/Jobs: BullMQ/Redis (or similar)

Cron/Scheduler
DB: existing (Prisma)
SEPA XML generation (pain.001)

Requirements
Strong experience with Node.js/TypeScript in production systems
Comfortable working in legacy/historically grown codebases
Solid understanding of:
API security & validation
background jobs/queues and retry patterns
multi-tenant architectures
financial workflows (status machines, auditability, idempotency)

Implementation
SEPA / payments / XML export experience
Experience with reconciliation workflows (bank statements/camt files)
CI/CD + testing mindset (unit tests / 1–2 E2E flows)

Skills: PHP, JavaScript, Node.js, Redis, AngularJS, API, Next.js

We are building a production-ready OCR-based financial verification and reconciliation system for a multi-location healthcare organization. This role focuses on automating high-risk financial workflows such as petty cash reconciliation, EHR transaction matching, and pharmacy invoice auditing, with a strong emphasis on accuracy, security, and audit readiness.
This is a backend-heavy full-stack role involving OCR pipelines, reconciliation engines, contract pricing logic, and secure AWS deployment, paired with clean, workflow-driven frontend implementation. The system is designed to scale across 300+ clinic locations and will later serve as the data foundation for advanced analytics.
Key Responsibilities
Design and implement OCR pipelines for handwritten petty cash sheets and pharmacy invoices


Build financial reconciliation logic comparing OCR outputs against EHR transaction exports


Develop contract pricing engines to detect overcharges, pricing violations, and uncontracted items


Implement role-based access control (RBAC), approval workflows, and full audit logging


Architect multi-location data segmentation with scalable filtering and reporting


Deploy and secure the system on AWS (VPC, private networking, encrypted storage)


Deliver a standalone, production-ready system with no future rework required


Core System Features
OCR extraction with confidence scoring


Automated discrepancy detection and variance reporting


Approval workflows (User → Admin → Super Admin)


Secure uploads, reconciliation reports, and invoice audits


Full audit trails with timestamps and user attribution


Tech Stack & Architecture
✅ Backend & APIs: Node.js / Python, REST APIs, reconciliation engines
✅ OCR & Document Processing: OCR pipelines for handwritten and printed documents
✅ Frontend: React / TypeScript (workflow-driven UI, approvals, reports)
✅ Database: PostgreSQL / relational data modeling
✅ Cloud & Security: AWS (VPC, encryption at rest & in transit, IAM)
✅ Compliance & Governance: RBAC, audit logs, non-self-approval enforcement
Ideal Background
Experience building financial reconciliation, audit, or compliance systems


Strong understanding of OCR accuracy thresholds and document processing


Comfort working with EHR data, invoices, and financial records


Ability to deliver enterprise-grade, secure, and scalable systems


This role prioritizes correctness, control, and long-term system integrity over dashboards or surface-level analytics.

We’re building a fast, modern sports fixtures + TV schedule platform at SportsFixtures.net, and we’re looking for one strong, reliable backend lead to help us finish the job properly and ship with confidence.

We care about speed, quality, and teamwork. We keep communication simple, we demo working progress daily, and we support each other to get the best result. If you’re the kind of person who enjoys owning delivery and shipping clean systems, you’ll fit right in.

The project (in plain English)

The product is already well underway. Your job is to take ownership of the backend delivery and bring everything together cleanly.

The frontend workstream (PWA / web / iOS / Android) relies on a stable backend contract — you’ll lead that contract so integration is smooth.

We use external sports data sources today and the architecture must be ready to add more providers later without rewrites.

There is also a venue display advertising pull layer that needs stable, fast endpoints/feeds.

Your role (what you’ll own)

You are the backend delivery owner for this sprint. That means you don’t just write code — you keep the whole backend moving forward, unblock integration, and ensure we ship working outcomes.

Week 1 goal: everything connected and fully operational

Week 1 is the most important week. By the end of Week 1, we want a fully working end-to-end system in staging:

Full end-to-end integration working

Backend endpoints stable and returning correct, predictable data

All required frontend sections connected and fully operational (not “wired up but flaky”)

Data flow stable and consistent

Venue display advertising pull connected and working (fast, cache-friendly outputs)

PWA live on staging and functioning end-to-end

Staging reliability from day one

Repo running locally quickly and cleanly

Staging dependable and deploys repeatable

Clear setup documentation (including env/secrets)

Basic CI checks in place (lint/tests/build)

Backend structure + admin usability

Strapi organised cleanly (content types, permissions, roles, policies, naming)

New admin GUI design implemented and functioning (layouts, fields, relations, workflows)

Permissions safe-by-default and easy for the team to use

API contract and provider abstraction

A clean v1 API contract for the pages we ship first

Frontend consumes your contract (not upstream quirks)

Normalisation + caching + throttling/rate limits in place where needed

Postman collection kept accurate and updated (OpenAPI is a bonus)

Security + performance baseline

Tenant/venue isolation enforced properly:

Tenant context from JWT only

Enforced in Strapi policies + service layer

Never trust client-supplied venue/tenant IDs

Negative tests proving venue A cannot access venue B

Input validation, auth hardening, and rate limiting where needed

Sensible DB hygiene (indexes and query sanity)

Background jobs & queues

Idempotent workers

Retry/backoff rules

Clear logging and visibility into failures

Safe re-run strategy when something goes wrong

Documentation that stays current

Runbook started immediately and updated as you go:

setup, deploy, rollback/restore, queue debugging

Practical handover notes so the next developer can continue smoothly

How we work (team-first, no lone wolf)

We ship quickly because we collaborate closely. You’ll never be left alone to guess what we want — we discuss decisions early, remove blockers fast, and keep the whole team aligned.

Daily rhythm:

Start of day: short meeting + plan (what will ship today)

During the day: quick updates when PRs are ready or blockers appear

End of day: what shipped / what’s next / blockers

Next-day plan: submitted at end of day so I can review early and support you

We want a positive working relationship and a smooth delivery rhythm.

Compensation (simple and friendly)

Total: $1,000 for the 1-month full-time sprint

$600 placed into escrow and released on completion (verified working)

$400 bonus paid on completion if KPIs/objectives are fully met (delivery, reliability, collaboration, and timelines)

What “completion” means

At the end of the month we should have:

Stable staging + repeatable deploys

Secure tenant isolation proven with negative tests

Queues/workers reliable with good failure visibility

v1 API contract stable and documented (Postman current)

PWA and the frontend/mobile workstreams fully integrated with stable endpoints

Venue display advertising pull working reliably

Clear documentation + handover notes delivered

We aim for everything to be submitted and live across web/PWA and mobile where platform review timelines allow. If app store review introduces timing, your responsibility is that the backend and integration are ready and stable so submission is smooth and fast.

Must-have skills

Hands-on Strapi v5

Node.js + TypeScript

PostgreSQL

Redis + background jobs/queues (BullMQ or equivalent)

API contract design + versioning

Multi-tenant security patterns + negative testing

Strong delivery ownership and clear communication

Nice-to-have

CI/CD basics, observability basics

Experience taking over existing projects and shipping quickly

Performance tuning and security hardening experience

Quick application questions (so we can move fast)

In your first message, please answer:

How do you enforce tenant isolation in Strapi (policy + service layer)?

How do you handle idempotency + retries/backoff in background jobs?

How do you design a clean API contract that hides provider quirks from the frontend?

What are your first 10 actions in Week 1 to get staging stable and integration working end-to-end?

Can you overlap ICT 06:00–15:00 daily for the full month?

Final note

We’re genuinely excited to find the right person and build a great working relationship. If you’re dependable, proactive, and enjoy shipping real products with a collaborative team, we’d love to talk.

I’ve finished the full Figma flow for a new minimalist-style social media app/Feed Type + Chat and now need it brought to life in React Native. The design is clean, spacious, and typography-driven, so pixel accuracy and smooth micro-interactions matter as much as the underlying code structure.

What I need from you
• Convert every Figma screen (light and dark modes) into high-quality React Native components, ready for both iOS and Android.
• Architect the project with today’s best-practice libraries—think React Navigation 6, Redux Toolkit / Zustand, TypeScript, ESLint + Prettier—so future contributors can jump in easily.
• Integrate the selected services:
– Social media platforms auth (Google, Apple, Facebook sign-in & share)
– Analytics tools (Firebase, Mixpanel or Amplitude)
• Build reusable UI atoms/molecules consistent with the minimalist look, ensuring smooth animations at 60 fps.
• Keep the repo tidy: modular folders, clear naming, thorough inline comments, and a concise README for setup.
• Be available for rapid iteration—small UI tweaks and feature refinements are part of the process.

Acceptance criteria
1. All Figma screens reproduced with ≤2 px variance.
2. Navigation, auth flow, and listed integrations fully functional on real devices.
3. No critical warnings in Xcode or Android Studio; passes basic unit tests and linting.
4. Performance: first screen paints <2 s on mid-range devices.

If you’ve shipped at least one React Native app to both stores and love clean, modern code, let’s talk.

Skills: JavaScript, Mobile App Development, Animation, HTML5, Agile Development, iOS Development, React Native, Figma, Tailwind CSS, AI Chatbot

About Ellty
Secure document sharing and analytics platform.

About role
This is a 6-12-month contract position - perfect opportunity to build strong Upwork profile with consistent full-time work, solid reviews, and portfolio-worthy projects.

You'll be the primary developer working directly with the founder. Full ownership of technical decisions and implementation. No bureaucracy, direct communication, fast decisions.

Tech Stack

Frontend: React, Next.js, TypeScript
Backend: Node.js, NestJS, MongoDB, Redis
Infrastructure: AWS (managed by dedicated DevOps)

Requirements

1-2+ years React experience (personal projects count)
1+ years Node.js and REST APIs
Can implement Figma designs accurately
Good written English
8h/day mon-fri
Self-motivated


Don't Apply If

Looking for part-time/side work (need full commitment)
Need constant supervision
Not willing to learn our tech stack

• Link to your GitHub
• How old were you when you earned your first money?
• How do you rate your skills as a specialist? a) I’m a beginner b) I’m always satisfied with my work c) I'm not always satisfied with my work d) I'm almost never satisfied with my work
• What's broken in your life that you're actively fixing?
• Rate your level as a developer: a) Senior - I know a lot b) Strong Middle - confident in my skills c) Middle with impostor syndrome d) Eternal Junior - always learning

Summary

We are validating a sealed backend ingress program (file_import) written in TypeScript with SQLite.

This is QA-only work.
No production code changes. No redesigns. No interpretation.

QA will create test data, create QA documentation, and execute tests in a provided non-production backend environment.

⸻

Role Overview
• Contract QA (Backend / Data Ingest)
• Short-term, hour-capped
• Scope: file_import only

Your job is to produce a clear, reproducible, audit-ready signal on correctness.

⸻

Current State
• Existing TypeScript backend codebase
• SQLite database
• file_import already implemented
• Sealed Product Design Document (PDD)

⸻

What You Will Do

1. Test Data & Fixtures
• Create all required test inputs for file_import:
• Valid inputs
• Invalid inputs
• PDD-explicit edge cases
• Ensure test data is:
• Minimal
• Explicit
• Reproducible
• Document each fixture:
• Purpose
• Expected outcome

2. QA Documentation
• Create QA artifacts:
• Test case list
• Step-by-step execution instructions
• Expected vs actual results
• Documentation must be:
• Clear
• Deterministic
• Runnable by another engineer without guessing

3. Backend Execution
• Run tests directly in the provided non-production backend environment
• Execute all testing from a QA-dedicated branch
• Validate via:
• Database state
• Logs
• Error output
• Confirm:
• Happy path unchanged
• Failures fail loudly
• No partial writes
• Deterministic outcomes

⸻

What You Will NOT Do
• No production code changes
• No refactors
• No redesign
• No new frameworks
• No assumptions beyond the PDD
• No “fixing” behavior
• No changes to environment configuration, runtime flags, or database settings
• No work of any kind on the main branch

Main branch is read-only.
All QA work must occur on a separate branch.

⸻

How to Work
• Use the PDD as the only source of truth
• Black-box testing only
• Create and use a QA branch for all activity
• Ask questions before assuming:
• Reference exact file + line when relevant
• Tag clearly: [QUESTION], [BLOCKER], [CONFIRMATION]
• Do not invent behavior

⸻

Deliverables (Required)

1. Test Data Package
• All fixtures used
• Clear naming
• Documented intent

2. QA Test Documentation
• Test cases
• Execution steps
• Expected vs actual results

3. QA Report
• Pass / Fail summary
• Repro steps for every failure
• File + line references when possible
• Evidence of determinism (repeated runs produce identical results)
• Failure classification for each issue:
• Bug
• PDD deviation
• Environment issue
• Explicit confirmations:
• “Happy path unchanged”
• “No silent failures observed”

No documentation = task incomplete.

⸻

Definition of Done
• Another engineer can rerun your tests exactly
• Results are deterministic and evidenced
• Findings are clear and immediately actionable
• Scope respected 100%
• No activity occurred on the main branch

⸻

Contract Details
• Trial-based
• Maximum billable time: 6 hours (hard cap)
• Execution window: 1–2 calendar days
• Same-day or next-day turnaround expected
• Task ends when the QA report is submitted or the 6-hour cap is reached (whichever occurs first)

⸻

Required Skills
• Backend QA experience
• TypeScript (reading and running backend code)
• SQLite inspection
• Creating backend-runnable test data
• Writing precise QA documentation
• Git (branches only; no main-branch work)

⸻

Fit

This role is ideal if you:
• Are methodical and skeptical
• Document as you test
• Respect sealed scope
• Treat main branch as untouchable

Not a fit if you like redesigning systems.

⸻

How to Apply

Answer directly:

Have you created backend-runnable test data and executed QA directly against a live TypeScript + SQLite backend, working exclusively on a branch and never on main.

Hello!

My daughter has built an app using Lovable, and as we publish it, we are seeing some vulnerabilities and security issues. We needed help fixing it, deploying it to the Android Play console, testing it successfully with 12+ testers, and going live. Can you assist?

Jaideep B

Hi I’m building a modular AI employee platform (customer support, booking, sales) using OpenAI + Make/n8n.
The first MVP is AI Customer Support (website chat + email) with:
– knowledge base
– confidence-based escalation
– conversation logging
Later we’ll add booking and sales modules.
Have you built something similar end-to-end?
Can you briefly explain how you’d structure the automation and escalation logic?

Please read the job description carefully before applying. Proposals that do not follow the job description will not be considered.

𝗪𝗼𝗿𝗸 𝗦𝗰𝗵𝗲𝗱𝘂𝗹𝗲 & 𝗖𝗼𝗺𝗽𝗲𝗻𝘀𝗮𝘁𝗶𝗼𝗻:
. 𝗪𝗼𝗿𝗸𝗶𝗻𝗴 𝗛𝗼𝘂𝗿𝘀: Indian Standard Time (IST)
. 𝗠𝗼𝗻𝘁𝗵𝗹𝘆 𝗦𝗮𝗹𝗮𝗿𝘆: $600/- USD
. 𝗟𝗼𝗻𝗴-𝗧𝗲𝗿𝗺 𝗢𝗽𝗽𝗼𝗿𝘁𝘂𝗻𝗶𝘁𝘆: If you consistently meet requirements and perform well, this is a full-time, long-term position

We are hiring a Full Stack Developer with strong AI/LLM experience to join our engineering team. This role combines backend engineering, 3rd-party API integrations, and modern AI (OpenAI, Gemini, LLaMA, Deepeeks) to build automation features for our SaaS platform.

💼 Responsibilities
AI / LLM Development
. Build and integrate AI features using OpenAI, Gemini, Deepeeks, LLaMA.
. Implement RAG pipelines, embeddings, indexing, and vector databases.
. Work with LangChain/LlamaIndex or custom RAG systems.
. Optimize prompts, data pipelines, normalization, and ML workflows.

Full Stack Development (MERN + Azure)
. Work with MongoDB, Express, React (Vite.js), Node.js, Next.js, Redux, Material UI.
. Build scalable backend APIs and microservices (NestJS/Express).
. Integrate 3rd-party APIs (Gmail, Office365, HubSpot, Zoho, Stripe, Google Sheets, etc.).
. Deploy & manage cloud services on Microsoft Azure using Azure DevOps CI/CD.
. Implement OAuth2.0, Firebase Auth, multi-threading, schedulers, CRON jobs.
. Optimize Linux servers for high concurrency (10k+ users).
. Work with MongoDB, PostgreSQL, ElasticSearch, Socket.io.

📌 Required Skills
. 4–7 years of full stack development.
. Strong backend engineering (Node.js, TypeScript, NestJS/Express).
. React.js with Vite.js and modern frontend tools.
. Deep Azure experience (DevOps, deployments, compute, storage).
. Strong knowledge of OAuth with Google/Microsoft.
. Experience with RAG, LLMs, vector DBs, data normalization.
. Skilled in large-scale scheduling, automation, event-driven systems.
. Linux expertise + multi-threading experience.
. API integration experience (Hubspot, Stripe, Zoho, etc.).

✨ Nice to Have
. SaaS platform or B2B automation experience.
. Firebase (Auth/Storage).
. Experience with scaling messaging/event-based systems.
. Experience with LangChain, LlamaIndex, DSPy.

We are looking for someone who wants to grow with us long-term and build advanced AI-powered systems.

• Describe your recent experience with similar projects
• Include a link to your GitHub profile and/or website
• What frameworks have you worked with?

Overview:

We are seeking an experienced Frontend / WebGL Engineer to continue development on an advanced, graphics-heavy simulation dashboard built with modern web technologies. The project is already performant on desktop after load, but it requires improvements to initial load performance, rendering correctness, and mobile usability.

This role involves taking ownership of performance optimization, fixing rendering and interaction issues, and refining the overall user experience across devices.

Current State:

Interactive dashboard rendering ~7,000 simulated entities
Desktop performance reaches up to ~180 FPS after initial load
Initial load time is currently high due to physics calculations
Mobile rendering and interactions are incomplete or broken

Key Areas of Work:

Performance & Rendering

-Reduce initial load time by restructuring when and how physics calculations run
- Fix incorrect initial rendering states (collisions, missing connections, ordering issues)
-Improve consistency between visual state and physics state

UI & Interaction

- Minor desktop UI refinements and control fixes
- Correct animation and rendering order issues during interactions
- Improve zoom behavior and visual consistency

Mobile Support

- Enable proper rendering of entities on mobile
- Fix touch gestures and scrolling behavior
- Optimize interaction responsiveness for smaller devices

Tech Stack

- Next.js 15 (Turbopack), React 19, TypeScript
- Three.js, @react-three/fiber, postprocessing
- Matter.js (physics)
- Tailwind CSS, Radix UI, Motion

Required Experience:

-Strong experience with Three.js and/or React Three Fiber

- Proven performance optimization experience in graphics-heavy applications

- Solid understanding of physics-driven or data-dense visualizations

- Strong TypeScript and modern React skills

How to Apply:

Please include

- Relevant WebGL / Three.js project examples

- Brief description of similar performance or optimization work

Project Overview

We are building a Reporting Tool and require an experienced React Native Expo developer to develop a Dashboard module for editing reports.
A fully functional web version already exists, and the backend + APIs are already implemented and working — no backend work required.
You will reuse existing API services and focus purely on frontend development.

This is a serious, fast-paced project. We are looking for someone who can commit fully and deliver efficiently.

⏰ Availability Requirement

Must work minimum 8 hours per day

High productivity and fast execution expected

Slow progress will not be appreciated

iOS device is mandatory for testing (we use iOS as primary testing platform)

🧱 Tech Stack (Must Have Experience)

React Native (Expo)

TypeScript

Proper typing for APIs and components required

NativeCN + NativeWind

TanStack Query (APIs already implemented)

React Hook Form

Zustand (State Management)

🧑‍💻 Coding Standards

Reusable components only

No large functions — break logic into small, maintainable functions

Single Responsibility Principle

Clean, readable, scalable code

No console logs in production commits

Code will be reviewed by our Lead Developer before merge

📋 Work Process

Daily Workflow:

At the start of each day → Share what you will work on

At the end of each day → Share progress update

Daily screen recording (Loom) required showing work progress

It will be a milestone based work. We have added all the features we need in github. We will assign the task to the developer. if the work is 5 hours estimated then we will make a milestone of 25 hour and after user complete that then we will release the milestone and give a new milestone. if you think a task will take longer then we will adjust the milestone.

📦 Delivery Process

All work must be pushed to GitHub

Build and upload app to TestFlight

Testing will be done via our TestFlight account

📝 Mandatory Application Line

Your proposal must start with this line:

I have an iOS device and can work a minimum of 8 hours per day

Applications without this line will be ignored.

🎯 Ideal Candidate

Strong Expo + React Native experience

Professional code quality

Comfortable working with existing APIs

Experience in structured team environments

Reliable, communicative, and disciplined

Can work independently and follow processes

This is our website. you can visit this and get an idea of the work.
https://app.reportwriter.ai/

• Describe your recent experience with similar projects
• Include a link to your GitHub profile and/or website
• What frameworks have you worked with?

We are looking for a highly skilled software developer to collaborate with our team on current and upcoming projects. This role is ideal for a developer who not only has strong technical expertise but can also communicate fluently in English (near-native or native level).

You will work closely with our team to deliver clean, scalable, and well-documented solutions. Clear communication, reliability, and technical ownership are essential.

Requirements
Proven experience as a software developer (backend, full-stack, or data/AI)

Strong proficiency in one or more modern stacks, such as:
Python / AI / Data Engineering
Node.js / JavaScript / TypeScript
Java (Spring Boot)
C# / .NET
Go (Golang)
Ability to design and work with APIs, databases, and scalable services
Fluent English communication skills (spoken and written)
Ability to work independently and meet agreed timelines

Compensation

Project Budget: $250 – $750 USD
Compensation will be based on experience, skills, and project scope
Opportunity for ongoing collaboration for the right candidate

How to Apply

Please include:
A brief introduction about yourself
Relevant experience or portfolio
Your primary tech stack
Your availability

Skills: Java, JavaScript, Python, .NET, Node.js, Software Development, Full Stack Development, Backend Development, API Development, Microservices

We are looking for full stack developers with strong knowledge of Typescript, Vite/NextJS, NodeJS, and PostgreSQL.

You will be working on an existing codebase to update existing features, and create new ones.

You MUST be an expert in both frontend and backend

+ also work weekends

We’re looking for a solid Expo React Native developer to help us build a task management mobile app with an integrated AI assistant.

The app already has a clear product direction and design system. Your job is to turn that into a smooth, polished mobile experience that actually feels good to use.

At a high level, you’ll be building core task features (create, edit, prioritize, schedule) and integrating an AI assistant that helps users plan their work, get suggestions, and stay productive. Think practical AI, not gimmicks.

What you’ll be doing

- Building the task management UI exactly as designed in Figma (spacing, colors, typography — details matter)
- Implementing core task features: create, edit, update status, priorities, and due dates
- Building an AI assistant experience (chat-style or contextual) that fits naturally into the task workflow
- Integrating AI APIs to generate task suggestions, summaries, and productivity insights
- Adding smooth animations and micro-interactions with Reanimated where it makes sense
- Managing global state for tasks, user context, and AI interactions (Zustand, MobX, etc.)
- Connecting to backend APIs for data persistence and sync
- Making sure the app stays fast and smooth, even with large task lists
- Writing clean, modular, maintainable code

What we’re looking for

- Strong experience with Expo (managed workflow)
- Solid React Native + TypeScript experience
- Proven ability to build pixel-accurate UIs from Figma
- Experience integrating third-party APIs, especially AI or chat-based APIs
- Comfortable with state management (Zustand, MobX, or similar)
- Experience using Reanimated (v2/v3)
- Knows how to build performant lists (FlatList, FlashList, etc.)
- Good understanding of mobile performance and app architecture

Nice to have (not required)

- Experience building chat or assistant-style UIs
- Hands-on experience with LLMs (OpenAI, Anthropic, etc.)
- Offline-first patterns or local persistence
- Background tasks, notifications, or reminders
- Gesture-driven interactions
- Experience shipping Expo apps to the App Store and Google Play

If you care about UX details, enjoy building clean mobile experiences, and are excited about practical AI inside real products, this will be a great fit.