DEV Community: Heghine

I Applied to Dozens of Freelance Developer Jobs on LinkedIn — Here's what Happened

Heghine — Wed, 08 Apr 2026 06:15:25 +0000

This week, my LinkedIn profile appeared 877 times.

I spent the last few days actively applying to freelance developer posts — sending messages, writing emails, and reaching out to people for React, Angular, and full-stack developers.

For long time, I didn't think deeply about the process of getting a job. I thought that building projects and learning new technologies would somehow help me start working as a freelancer.

It wasn't.

So instead of continuing to learn endlessly, I decided to do something different: I started treating LinkedIn like a real opportunity source — and began applying consistently.

What happened next was surprisingly different from what I expected.

What I Actually Did

Instead of just scrolling or learning passively, I started taking action:

Applied to multiple freelance posts every day;
Sent emails and LikedIn DMs;
Shared my work (my Real-Time Chat App and portfolio);
Shared conversations with potential clients.

I don't want to feel "ready." I just started.

What I Learned

1. Most People Don't Reply

This was the first thing I noticed. You can send multiple messages, and get no response at all. At first. it feels like rejection. But it's not.

I just how things work.

People are busy;
Posts get flooded with messages;
Many applications are ignored.

This is normal.

2. Timing Matters More Than I Expected

Applying early makes a big difference.

Posts that are:

Recently published;
Have fewer comments.

Are much more likely to get a response.

If you apply late, you're just one of many.

3. Messaging Matters

At first, I wrote very genetic messages. They didn't work well. What I worked better was being clear and direct:

What I can build;
What I've already built;
How I can help with their project.

People don't want long introductions. They want to understand quickly if you're useful.

4. A Board Tech Stack Helps — But Not in the Way I Expected

One unexpected advantage I had was knowing multiple frameworks. Since I've worked with:

Angular;
React;
React Native;
Next.js;
Vue.js;
Nest.js;
Node.js.

I didn't have to skip many posts.

I could apply to wide range of opportunities:

Frontend;
Full-stack;
Sometimes even backend-focused roles.

But this doesn't mean you need to learn everything. What actually matters is:

Being able to build real things.

The tech stack just gives you more entry points.

Real Conversations Started to Happen

After some time, I started getting responses.

Not many — but enough to notice a pattern.

I had a conversation about a JAMStack role and went through an interview.
I connected with other developers.
Some people told me they might reach out in the future.

Nothing immediate came out of it, but it felt like I was no longer just sending messages into nothing.

Eventually, I started having actual conversations with potential clients.

In one of them, I was asked:

"What are your charges for an app?"

It wasn't surprising — just a bit unexpected how quickly the conversation moved to pricing.

I tried to understand the project first and asked about the scope.

But they asked again.

So I gave a simple range:

basic MVP: around $300–800

They said they would get back to me. And maybe they will, maybe they won't. But that wasn't the important part.

The important part was that the process had changed:

From applying to having real discussions.

Advice If You're Starting

Don't wait until you feel ready;
Apply even if you don't match every requirement;
Build at least one real project;
Keep sending messages, even if most don’t reply.

Consistency matters more than perfection.

Afterword

I'm currently building and sharing my work publicly, including a Real-Time Chat Application and other ongoing projects.

I'm also open to freelance opportunities.

GitHub: https://github.com/ZeroaNinea/
Portfolio: https://heghine-app.netlify.app

I Built a Real-Time Chat App From Scratch — Then Realized That Wasn't Enough

Heghine — Mon, 30 Mar 2026 05:52:48 +0000

Source

GitHub: https://github.com/ZeroaNinea/Real-Time-Chat-App

Why I Built It

I started this project as a simple pet project to help me get a job.

I built a real-time chat application from scratch, solving problems step by step and turning it into something that actually worked.

But after finishing it, I didn't immediately start applying.

Instead, I thought:

"I need to learn more first."

So I spent the next seven months learning frameworks like React, Vue, Next.js, and Nest.js.

Only later did I realize something important:

I could have already started looking for a job.

After that, I spent two more months on LinkedIn and writing posts, but still didn't get results.

That's when it became clear:

Building projects is important.
Learning is important.
But knowing how to present yourself and reach people matters just as much.

The Biggest Challenge: WebSockets and Structure

One of the hardest parts of the project was working with WebSockets using Socket.io.

At the time:

I didn't fully understand how it worked.
I couldn't properly connect users to rooms.
all my Socket.io logic was in one huge file.

It quickly became difficult to manage.

The real issue wasn't just bugs — it was structure.

After refactoring:

I split the logic into smaller parts
separated responsibilities
made the system easier to understand

That was a turning point.

Mistakes I Made

A major mistake was not clearly separating real-time and non-real-time logic.

I relied heavily on WebSockets early on, which led to:

Mixing different types of functionality.
Unclear architecture.

If I were to rebuild it, I would:

Use REST APIs for standard operations.
Use WebSockets only where real-time updates are necessary.
Define clear boundaries from the beginning.

What I'd Improve

There's still a lot I want to improve:

Features

File uploads (images, videos, text files).
Highlighting the current channel.
Customizable themes (including dark mode variants).
Movable UI elements.

UX

Better message display and layout

Architecture

End-to-end encryption.
A separate service for encryption key rotation.

What I Learned

The biggest lesson wasn't technical.

It was this:

Building something real is necessary — but it's not enough on its own.

You also need to:

Show your work.
Communicate clearly.
Reach the right people.

Otherwise, even a solid project can go unnoticed.

Afterword

This project became more than just a chat app.

It taught me:

How to build real systems.
How to deal with complexity.
And how important visibility is.

If you're learning development, don't just build —
make sure people can actually see what you've built.

Build a Modern Stack with Vite, Tailwind, i18next, and TanStack Router

Heghine — Fri, 20 Mar 2026 13:43:58 +0000

Source: https://github.com/ZeroaNinea/React-Vite-i18next--tanstack-react-router-Tailwind-Example

Setting up a modern React project can quickly turn into dependency chaos — especially when combining routing, styling, and internationalization.

In this guide, you'll build a clean, production-ready setup using:

⚛️ React
⚡ Vite
🎨 Tailwind CSS
🌍 i18next
🧭 TanStack Router

⚠️ Warning (Version Compatibility)

Depending on your Vite version, some dependencies may not install cleanly.

If you run into issues:

npm i --force

Or consider using a slightly older version of Vite.

🚀 Step 1 — Create the Project

npm create vite@latest React-Vite-i18next-@tanstack/react-router-Tailwind-Example -- --template react-ts

🎨 Step 2 — Install Tailwind CSS

Install Talwind and its Vite plugin.

npm i tailwindcss @tailwindcss/vite

If installation fails:

npm i --force @tailwindcss/vite

Configure Vite

import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
import tailwindcss from '@tailwindcss/vite';

export default defineConfig({
  plugins: [react(), tailwindcss()],
});

Import Tailwind

@import 'tailwindcss';

🧭 Step 3 — Install TanStack Router

npm i @tanstack/react-router @tanstack/router-devtools

🔌 Step 4 — Integrate the Router

Create:

src/router.tsx

Then connect it in main.tsx:

import { StrictMode } from 'react';
import { createRoot } from 'react-dom/client';

import './index.css';
import { AppRouter } from './router.tsx';

createRoot(document.getElementById('root')!).render(
  <StrictMode>
    <AppRouter />
  </StrictMode>,
);

🌍 Step 5 — Add Internationalization (i18next)

Install:

npm i i18next react-i18next

Setup i18n

Create:

src/utils/i18n/index.ts

Add your translation JSON files there.

Then import it once in your app:

import './utils/i18n';

Finally, integrate it inside your components (e.g. App.tsx).

Why This Stack?

This combination is surprisingly powerful:

Vite: instant dev server, fast builds.
Tailwind: no context switching for styling.
TanStack Router: type-safe, modern routing.
i18next: scalable internationalization.

Together, they form a minimal but production-ready architecture.