😂I Missed the Hackathon Deadline, But Solved a Bigger Problem: Finding the Right Project Partner.

Source: Dev.to

You’ve got ideas.
You’ve got skills.
You’ve got motivation.

But somehow… you’re still building alone.

So I decided to build Projura — an app designed to help developers, designers, and builders find the right project partners, not just random teammates. While building it, I learned how real‑world collaboration apps actually work.

What Is Projura?

Projura is a full‑stack web app where users can:

• ✅ Create a profile
• ✅ Add skills
• ✅ Post project ideas
• ✅ Match with collaborators based on skills
• ✅ Stop building alone

No fake networking. No endless DMs. Just skill‑based collaboration.

The Core Idea: Matching Humans Like Code

Projura doesn’t match people randomly. It uses structured data:

• User skills
• Project requirements

Because software doesn’t understand vibes — it understands logic.

Step 1: Creating a User Profile (Backend Logic)

Frontend (JavaScript)

async function createUser() {
  const res = await fetch("http://127.0.0.1:5000/users", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      name: name.value,
      bio: bio.value,
      skills: skills.value
    })
  });

  const data = await res.json();
  userId = data.id;
}

Backend (Flask API)

@app.route("/users", methods=["POST"])
def create_user():
    data = request.json
    user = User(
        name=data["name"],
        bio=data["bio"],
        skills=data["skills"]
    )
    db.session.add(user)
    db.session.commit()
    return jsonify({"id": user.id})

This is where Projura officially knows you exist.

Step 2: The User Model (Where Data Lives)

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100))
    bio = db.Column(db.Text)
    skills = db.Column(db.Text)

Skills are stored as comma‑separated values, e.g.:

"python, flask, frontend"

Easy to store. Easy to compare.

Step 3: Projects Need Requirements

class Project(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(150))
    description = db.Column(db.Text)
    required_skills = db.Column(db.Text)

Now projects speak the same language as users: skills.

Step 4: Matching Logic (The Smart Part)

from difflib import SequenceMatcher

def skill_match(a, b):
    return SequenceMatcher(None, a, b).ratio()

We compare user skills vs. project skills; a higher similarity ratio means a better match. This turns collaboration into data‑driven decisions.

Step 5: Frontend + Backend Must Agree

fetch(`${API}/projects/${userId}`)
  .then(res => res.json())
  .then(data => {
    projects.innerHTML = data.map(p =>
      `- ${p.title}
`
    ).join("");
  });

APIs are contracts. Break them — nothing works.

Step 6: Debugging = Real Learning

Typical problems I hit:

• ❌ Button clicks but nothing happens
• ❌ API called but returns 500
• ❌ Database schema mismatch
• ❌ CORS blocking requests

Each error forced me to learn:

• How databases don’t auto‑update
• Why frontend and backend must match
• Why logs matter
• Why “it runs” ≠ “it works”

This is where theory becomes engineering.

Why Projura Matters

• Beginners struggle to find teammates
• Skilled people often build alone
• Great ideas die early

Projura connects people based on what they can actually build together.

Possible Future Upgrades

• 🔥 Real‑time chat
• 🔥 GitHub integration
• 🔥 Recommendation scoring
• 🔥 Project timelines
• 🔥 Team dashboards

Each feature pushes Projura closer to production.

Final Thought

Projura taught me something important: apps aren’t about code; they’re about turning human problems into logic. If you can design systems that help people connect meaningfully, you’re not just coding — you’re building impact.

# coders language 
print("Happy building 🚀💻 ")