At least 2 years of development experience.

Experience building E-commerce websites is required.

European and US developers(we important time zone.)

$40/hr

Payment negotiable based on previous experience and level of experience.

The final candidate will begin work on March 15th. If the candidate applies, the post will be revised.

This is not a short-term assignment, as we will be able to address any issues that arise during the site's use.

Please attach a portfolio and a brief description of the most challenging aspect of your previous website development.

Proposals without this information will not be accepted.

Hi guys,

Over the weekend, I generated animated, two-tone icon libraries with CSS-only hover animations. Currently supports Lucide (1,933 icons), Heroicons (324 icons), and Iconoir (1,383 icons). They have zero JavaScript animation dependencies.

https://animated-icons.vercel.app/

You can use them in your projects.

PRs welcome: https://github.com/gorkem-bwl/animated-icons

Hey r/reactjs,

I've been working on React Trace, a devtool to run together with your app during development and lets you visually inspect any rendered component.

What it does:

• Hover any element to see the component that rendered it and then choose what to do:
• Copy the file:line reference to clipboard.
• Open the file in your favorite editor (VS Code, Cursor, Windsurf, WebStorm, or IntelliJ)
• Preview the source code with Monaco and edit it directly in the browser.
• Add multiple inline comments to specific components, then copy them all to send to your AI agent (or send them directly to OpenCode with its native integration)

Setup is minimal:

Install:

pnpm add -D @react-trace/kit 

Then update your package.json to expose the project root to the tool:

"dev": "VITE_ROOT=$(cwd) pnpm dev" 

Then render the component side-by-side with your app:

<Trace root={import.meta.env.VITE_ROOT} /> 

It ships with conditional exports that resolve to no-ops in production, so there's zero runtime cost in production builds.

Plugin system:

If you want to extend it, you can build plugins that hook into the toolbar, action panel, or settings. There's a scaffolding CLI (pnpm create react-trace-plugin) and full docs.

Site: https://react-trace.js.org

GitHub: https://github.com/buzinas/react-trace

Happy to answer any questions. Feedback welcome!

Hey r/reactjs! I just released an interview with Aurora Scharff (DX Engineer at Vercel, React Certification Lead at certificates.dev) and thought folks here might find it interesting.

We talked about:

Her path into React

- Started in robotics and intelligent systems, found her way into web dev

- Went deep on React and Next.js, became a Microsoft MVP

- Recently joined Vercel to work on developer experience

React Server Components

- Why RSCs require a real mental model shift, not just learning new syntax

- Experienced React devs often struggle more than newcomers because they keep reaching for client-side patterns

- How to think about the server/client boundary when designing components

Next.js App Router vs Page Router

- The shift isn't just an API change, it's a fundamentally different way to structure apps

- Practical lessons from rebuilding a legacy government system on the App Router

- Deploying on Vercel vs Azure and what surprised her

React certifications in the AI era

- She's building the React certification at certificates.dev

- Her take: when AI can generate code, proving you understand the fundamentals becomes more important

- Certifications aren't about gatekeeping, they're about depth of understanding

Speaking and community

- How she went from zero talks to 30+ conference appearances

- Why putting yourself out there early matters even when you feel like you're not ready

Full episode here:

- YouTube: https://youtu.be/4Llhem0M1Og

- Spotify: https://open.spotify.com/episode/6UW8rszpV4eOAYwxK4trH4

Would love to hear your thoughts or answer any questions!

Also suggest me some guests you want to see!

I built a CLI tool that replaces localhost:4231 with myapp.localhost:7777. It auto-detects your project name, proxies traffic (including WebSockets), and has a built-in dashboard.

curl -fsSL https://raw.githubusercontent.com/thirukguru/localias/main/install.sh | bash

Written in Go, single binary, open source.

https://github.com/thirukguru/localias

Hey everyone,

I recently launched Frontscope (https://www.frontscope.dev/), a free platform to help frontend devs (especially juniors/intermediates) really get core concepts.

Main highlights:

• Core frontend topics (CSS layouts, flexbox/grid, positioning, JS closures, event loop, promises/async, React hooks, etc.) explained with smooth animations + interactive demos

• Built-in JavaScript DSA practice problems (arrays, strings, trees, etc. with visual step-by-step execution)

• Curated FAANG-style frontend interview questions + explanations

• ATS-friendly resume builder tailored for frontend roles

• Flashcards, quick cheatsheets, and short blog-style deep dives

It’s still very much a work in progress — I’m adding more content weekly based on what people find useful.

If you’ve got 2–3 minutes, I’d genuinely appreciate:

• What feels most helpful / unique?

• Any confusing parts or topics that are missing?

• Bugs / UX annoyances you spot right away?

No pressure to sign up or anything — just trying to make something actually useful for the community I learn from every day.

Thanks in advance for any thoughts!

Built something called **WorkerFlow** over the past few months to deal with heavy processing tasks in React without making the interface unresponsive.

**Background:**

Was developing an application that did a lot of data crunching on the frontend and the whole UI would lock up constantly. Manually setting up Web Workers was a nightmare - creating separate files, dealing with all the message passing code, handling state management... way too much overhead for what should be straightforward.

**How it works:**

// Define your heavy operation once

flow.define('crunchNumbers', (dataset) => {

// Executes in Web Worker thread

return intensiveCalculation(dataset);

});

// Use with standard React patterns

const { result, isLoading, error, execute } = useWorker('crunchNumbers');

**Key features:**

- Built-in React hooks for loading/error handling

- Smart worker pool management based on CPU cores

- WASM integration for performance boosts

- Full TypeScript definitions

- Around 2.8KB compressed

**What I need:**

- Brutal feedback - does this solve a real problem or just creating more complexity

- Anyone willing to test it and report issues

- Suggestions for additional functionality

- Open to collaborators if this interests you

**Repository and demos:**

- Source: [WorkerFlow GitHub](https://github.com/tapava/compute-kit)

- Working example: [Live Demo](https://computekit-demo.vercel.app/)

- Packages: [WorkerFlow/Core](https://www.npmjs.com/package/@computekit/core) | [WorkerFlow/React](https://www.npmjs.com/package/@computekit/react)

First time putting together an open source project so any input is valuable - even if its just telling me this is redundant or completely wrong approach.

Hey everyone,

I've been working on a WhatsApp chatbot builder for the past few months and just open sourced it. Figured it might be useful to others.

What it does:

It's basically a visual flow editor where you design chatbot conversations by dragging and connecting nodes on a canvas - similar to how tools like n8n or Zapier work, but specifically for WhatsApp chatbot logic. You build the flow visually, connect it to WhatsApp Cloud API, deploy it, and your bot is live.

The node types (11 total):

• Message - send text
• Button - interactive buttons (up to 3)
• List - list selection messages
• Input - collect user input with validation (text, number, email, phone, regex)
• Condition - branch logic (keyword match, variable comparison, logical expressions)
• Delay - pause execution
• API Call - make HTTP requests with auth, headers, body, response mapping, retry logic
• AI Reply - generate responses via OpenAI, Gemini, Groq, Mistral, OpenRouter, or custom providers
• Loop - iterate over arrays, count ranges, or condition-based
• Go to Subflow - jump to a reusable subflow
• End - terminate flow

What makes it not just another toy project:

• Built-in simulator - test your entire flow in the browser without sending actual WhatsApp messages. Uses the same execution engine as production.
• Draft/deploy workflow - edit things without breaking your live bot
• Version history with rollback (keeps last 3 deployed versions)
• Bot variables (global) + session variables (per conversation)
• Real-time conversation viewer
• AI integration with configurable model params (temperature, max tokens, etc.) and token usage tracking
• AES encryption for stored API keys/tokens
• Rate limiting, JWT auth, Helmet.js

Tech stack:

• Frontend: React 19, TypeScript, Vite, Redux Toolkit, Tailwind CSS
• Backend: Node.js, Express, TypeScript, MongoDB/Mongoose
• Auth: JWT + bcryptjs
• Encryption: crypto-js (AES for sensitive data)

What I'd do differently if I started over:

• The NodeSettingsPanel.tsx is ~141KB and handles all 11 node types in one file. It works but it's getting unwieldy. Would break it into per-node-type components.
• Would add WebSocket support for real-time updates instead of polling
• Would write tests from day one (there are none right now, I know, I know)

Known limitations:

• Vercel deployment only works as a showcase — delay nodes, cron jobs, and long-running executions need a persistent server (VPS or Docker recommended)
• No tests yet
• Single-file settings panel needs refactoring

GitHub: https://github.com/theabhipatel/wa_flow_builder

MIT licensed. Use it for whatever you want — business, learning, building your own product on top of it, don't care.

PRs welcome. If you want to contribute, just target the dev branch. Bug fixes, new features, docs all good.

Happy to answer any questions about the architecture or implementation.

When learning React, some concepts look simple at first but take time to truly understand.

For me, things like:

• useEffect behavior during re-renders

• state updates and batching

• component re-render optimization

took some time before they fully clicked.

I'm curious — what React concept took you the longest time to fully understand?

When I first started learning React, my code worked but it wasn't always clean or scalable.

Over time I realized that small practices make a big difference, like:

• Keeping components small and reusable

• Avoiding direct state mutation

• Using meaningful variable names

• Proper useEffect dependency management

What are some small React practices you follow that greatly improve code quality?

While working on React projects I realized that debugging often takes more time than writing the actual code.

A few things that helped me a lot:

• React DevTools for checking component state

• Console logging state updates

• Breaking complex components into smaller ones

But I feel every developer eventually discovers one trick that saves a lot of debugging time.

So I’m curious — what’s one React debugging trick that saved you hours?

Hey everyone,

I kept redoing the same setup (auth, payments, i18n) every time I started a new project, so I bundled it into a single CLI. I’d love some real-world feedback from the React community on the architecture and Developer Experience.

What it does: You run npx @/x-legacy/create-saas-app, pick your options, and you get a production-ready Next.js 16 app with deploy configs. No wiring, no copy-paste.

The Stack & Technical Details:

• Framework: Next.js 16 (App Router)
• Auth & Database: Supabase (Postgres + 14 OAuth providers)
• Payments: Stripe (subscriptions, usage-based)
• ORM: Drizzle
• Localization: next-intl (21 locales + RTL support)
• State/Roles: Built-in teams & roles (owner, admin, member, viewer, billing)

Why I’m posting: It’s completely free to use — sign up on the website and I’ll give you access.

I’m looking for honest feedback from other React devs. Did it save you time? Was the folder structure or Next.js implementation confusing? Would you use it for a real project? Happy to go deeper on the stack or the CLI logic in the comments if anyone’s curious.

Sign up here and I’ll give you access:https://x-legacy.space

Thanks in advance if you give it a spin!

Hey everyone, I got tired of manually mapping API payloads to forms and validation schemas. I built this small utility to automate the process: Paste JSON -> Get RHF + Zod code.

Check it out here: https://payload-form.vercel.app/

It's a simple MVP I built in a day. Would love to hear if this is useful for your workflow or if I should add something like an Admin Dashboard generator next.

(There's a "Buy me a coffee" button if it saves you a headache!)

If you're using Hono for your backend and TanStack Query in your React app, you’ve probably written a lot of fetch wrappers and repeated types between the server and client.

I ran into the same problem, so I built hono-tanstack-query.

It helps connect Hono APIs with TanStack Query so React apps can call Hono endpoints with less boilerplate while keeping everything type-safe.

https://www.npmjs.com/package/hono-tanstack-query

It’s still early, so I’d love feedback, ideas, or suggestions from anyone using Hono or TanStack Query.

If you have 1+ year of experience in React.js and front-end development, join us to build dynamic, high-performance web applications—no fluff. Focus on clean code, user experience, and scalable solutions.

Details:

$22–$42/hr (depending on experience)

Remote, flexible hours

Part-time or full-time options

Design, develop, and maintain React applications with an emphasis on performance, responsiveness, and security

Interested? Send your location📍

Hey everyone,

I’m a solo dev, and I've spent the last few months building a highly performant, open-source React data grid (reactdatagrid.dev). My background is in building heavy UI components (I previously maintained the WPF Extended DataGrid on CodePlex), and I wanted to bring that same level of enterprise functionality to React for free.

It currently supports things like Pivot Tables, Tree Data, and complex Column Grouping out-of-the-box.

Last night, I pushed a massive update adding Server-Side Sorting, Filtering, and Pagination. Handling the state hand-off between the grid's internal UI and a developer's backend API is always tricky, so I built a live demo that visually logs the mocked API requests as you interact with the grid.

I would love some feedback from senior React devs:

1. Does the API implementation feel intuitive to you?
2. Are there any server-side edge cases I missed in the documentation?

You can test the server-side features (and copy the implementation boilerplate) here:https://reactdatagrid.dev/demo/server-side

GitHub Repo:https://github.com/bhushanpoojary/react-open-source-datagrid

Thanks in advance for any critiques!

Started learning react recently after doing HTML CSS and JS,

I am learning react through tutorials, in which the guy is building something, and I am not able to follow him, because there are so many things to remember, do I need to note everything and remember everything, and tips please

The app can be downloaded through https://pabl0parra.github.io/RawCut/

RawCut video