From Zero to $18,000+: My Unexpected Journey on Upwork as a Self-Taught Developer

Rahees Ahmed — Wed, 11 Sep 2024 04:56:59 +0000

In the world of tech, experience often seems like the golden ticket. But what if I told you that even without years of professional experience, you could still make a significant income? This is my story of how I went from rejected job applicant to successful freelancer, earning over $18,000 on Upwork without any prior freelancing experience.

The Rocky Start

My journey began in 2023 with my first job interview. The task? Create a company dashboard with medical billing information. I poured my heart into it, completing the project in just two days. Excited and hopeful, I waited for their response. Days turned into weeks, and despite my follow-ups, silence prevailed. When they finally replied, their words stung: "Sorry, we need someone with more than 5 years of experience."

This pattern continued. Companies would ask for my projects, then my CV. I couldn't understand why a CV mattered more than my actual work on GitHub. The rejections piled up, and so did my self-doubt. Was all my learning for nothing? Even reaching out to established Pakistani freelancers for guidance led nowhere.

A Promise and a Pivot

Frustrated but determined, I made a promise to myself: No more applying for traditional company jobs. It was time to become my own boss through freelancing.

I dove into learning Bubble.io, creating free plugins that gained popularity. I also developed free WordPress plugins. But something was still missing.

The Game-Changer: Machine Learning

Everything changed when I started learning machine learning. This new skill, combined with my existing knowledge of Node.js, Next.js, WordPress, Bubble.io, and Python, opened up a world of possibilities. I created a variety of open-source projects, ranging from simple to complex user interfaces. I also contributed to other open-source projects, further honing my skills.

Cracking the Upwork Code

With my expanded skill set, I turned my attention to Upwork. But I didn't jump in blindly. I spent three days studying the platform, analyzing what clients in my field were looking for. Using these insights, I crafted my profile to match their needs, increasing my visibility in searches.

Pro tip: Specialize in a specific area. It makes finding relevant jobs much easier.

The Unbelievable First Job

After getting my account approved, I sent my first proposal, showcasing my past work. To my amazement, I received a response within 5 minutes. After a brief discussion about my work, I was hired. The kicker? My first job paid $3,000. It sounds unbelievable, but it really happened.

Lessons Learned

Don't undervalue yourself: Just because you're new doesn't mean you should charge rock-bottom prices. Set fair rates that reflect your skills.
Prioritize client satisfaction: Be available and helpful. Building trust is key to long-term success.
Create a strong profile: After my second job, I stopped sending proposals. Clients started inviting me based on my well-crafted profile.
Ignore the noise: Don't listen to self-proclaimed YouTube experts. Trust your instincts and experiences.
Commit fully: Whatever you decide to do, give it your all. Be patient and don't just chase money.
Never stop learning: Continuously update your skills and explore new technologies.

The Power of Persistence

From that point on, I haven't sent a single proposal. All my work comes from invitations, thanks to my strong profile, helpful attitude, and diverse skill set.

Remember, if I can do it, so can you. Don't let setbacks discourage you. Keep learning, keep helping others, and keep pushing forward. That's the real secret to freelancing success.

Your journey might be different, but the principles remain the same: dedication, continuous learning, and genuine client care can take you far in the world of freelancing, even without traditional experience.

A Comprehensive OpenAI Assistants API V2 Wrapper: Simplifying AI Integration

Rahees Ahmed — Tue, 10 Sep 2024 22:28:05 +0000

Hello developers,

Today, I'm introducing an OpenAI Assistants API Wrapper that I've developed to streamline the integration of OpenAI's Assistants API into your projects. This wrapper provides a straightforward interface to interact with the full range of OpenAI's Assistant capabilities, built on the pure OpenAI Assistants API without any third-party dependencies.

Key Features

Complete API Coverage: Includes all options from the Assistants API, providing full functionality.
Simple Streaming: Implements streaming capabilities without relying on external libraries.
Robust Error Handling: Designed to manage and report errors effectively.
Easy Setup: Minimal configuration required to get started.

Getting Started

Setting up the wrapper is straightforward:

git clone https://github.com/RaheesAhmed/openai-assistants-api-v2.git
cd openai-assistants-api-v2
npm install

Configure your environment by setting up a .env file:

OPENAI_API_KEY=your_openai_api_key

Core Functionalities

Creating an Assistant

const createAssistant = async () => {
  const response = await fetch('http://localhost:3000/create-assistant', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      name: "Data Analyst",
      instructions: "You are a data analysis assistant.",
      model: "gpt-4-1106-preview"
    })
  });
  const data = await response.json();
  console.log('Assistant created:', data);
};

Managing Threads and Messages

const createThreadAndMessage = async () => {
  // Create a thread
  const threadResponse = await fetch('http://localhost:3000/create-thread', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      messages: [{ role: "user", content: "I need help analyzing this dataset." }]
    })
  });
  const thread = await threadResponse.json();

  // Add a message to the thread
  const messageResponse = await fetch(`http://localhost:3000/create-message/${thread.id}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      role: "user",
      content: "Can you identify any trends in this data?"
    })
  });
  const message = await messageResponse.json();

  console.log('Thread and message created:', { thread, message });
};

Running an Assistant

const runAssistant = async (threadId, assistantId) => {
  const response = await fetch(`http://localhost:3000/create-run/${threadId}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ assistant_id: assistantId })
  });
  const run = await response.json();
  console.log('Run created:', run);
};

Implementing Streaming

One of the key features of this wrapper is its built-in streaming capability:

const streamRun = async (threadId, runId) => {
  const response = await fetch(`http://localhost:3000/stream-run/${threadId}/${runId}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ stream: true })
  });

  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  while (true) {
    const { value, done } = await reader.read();
    if (done) break;
    console.log('Streamed data:', decoder.decode(value));
  }
};

Error Handling

The wrapper includes a global error handling middleware that catches and processes errors, returning them in a consistent format:

{
  "error": {
    "message": "Specific error message"
  }
}

This approach simplifies debugging and improves the overall reliability of your application.

Additional Features

File Operations: Upload, list, retrieve, and delete files associated with assistants.
Vector Stores: Manage vector stores for efficient information retrieval.
Configuration Management: Easily update rate limits, file size restrictions, and API keys.

Practical Applications

This wrapper is suitable for various applications, including:

Chatbots for customer service
Data analysis assistants
Educational tools and tutoring systems
Content generation platforms

Conclusion

This OpenAI Assistants API Wrapper offers a practical solution for developers looking to integrate OpenAI's capabilities into their projects. Its straightforward design, comprehensive coverage of the Assistants API, and built-in streaming support make it a valuable tool for AI-powered application development.

For more information, usage examples, or to contribute to the project, visit the GitHub repository.

Your feedback and contributions are welcome as we continue to improve and expand this tool.

Forem: Rahees Ahmed