Forem: FaynoSync

Team-Based Authorization in faynoSync — An Overview for Developers

Serhii Kuianov — Mon, 08 Sep 2025 07:10:43 +0000

Before we dive into team authorization, a quick word about faynoSync.

It’s a dynamic update server that lets developers and teams manage app distribution, updates, platforms, architectures, and release channels — all in one place.

When your project starts growing, you’re no longer the only one deploying, testing, or publishing applications. Suddenly, you need to answer questions like:

Who can upload builds?
Who can edit applications?
How do I keep different teams isolated?

This is where faynoSync’s Team-Based Authorization comes into play. It provides a structured way to manage access across multiple users while keeping resources secure and isolated.

🔑 Key Concepts

Administrator

Manages their own team.
Can create, update, delete team users.
Full control over passwords and permissions.
Access limited to their team’s resources.

Team User

Belongs to a single administrator.
Cannot manage other users.
Works only with resources explicitly permitted.
Everything created belongs to their admin.

⚙️ Resource Permissions

Permissions are defined per resource type:

Applications
Channels
Platforms
Architectures

Available actions:
create, edit, delete, upload (apps only), download (apps only).

🧩 Example: Managing Team Users via API

Create a Team User

curl -X POST 'http://localhost:9000/user/create' \
  -H 'Authorization: Bearer <jwt_token>' \
  -H 'Content-Type: application/json' \
  -d '{
    "username": "teamuser1",
    "password": "password123",
    "permissions": {
      "apps": {
        "create": true,
        "delete": false,
        "edit": true,
        "download": true,
        "upload": false
      }
      // ... other permissions
    }
  }'

Update Permissions

curl -X POST 'http://localhost:9000/user/update' \
  -H 'Authorization: Bearer <jwt_token>' \
  -H 'Content-Type: application/json' \
  -d '{
    "username": "teamuser1",
    "password": "newpassword123",
    "permissions": {
      // ... updated permissions
    }
  }'

📊 Resource Isolation

Team users only see resources they’re allowed to use.
Each admin’s resources are completely isolated.
Admins can always see what their team creates.
Different teams can have resources with the same names.

🖥️ Using the Web Dashboard

For those who prefer UI over API, the faynoSync Dashboard makes team management straightforward.

Below you’ll also find a few screenshots to better visualize how these features look in action. 👇

Creating/removing team users.
Setting or auto-generating passwords.
Updating usernames and credentials.

Assigning permissions with checkboxes.

Team users can log in to see their permissions and available resources at a glance.

✅ Conclusion

As your team scales, so does the need for granular access control.
faynoSync’s Team-Based Authorization helps you:

Keep teams isolated and secure.
Assign precise permissions for every resource.
Manage users both via API and Dashboard.

This way, you don’t just share your infrastructure — you control it.

How to Try faynoSync

Follow the Getting Started guide:
👉 https://faynosync.com/docs/getting-started

You can create your app using the REST API or the web dashboard:

⚡ API source code: https://github.com/ku9nov/faynoSync

📦 API Docs: https://faynosync.com/docs/api

🖥️ Dashboard UI: https://github.com/ku9nov/faynoSync-dashboard

🎬 Dashboard UI demo (video): https://faynosync.com/demo

Upload at least two versions of your application and check for updates with a simple request:

curl -X GET --location 'http://localhost:9000/checkVersion?app_name=appName&version=0.0.1&channel=stable&platform=linux&arch=amd64&owner=admin'

Or in Javascript:

import fetch from "node-fetch";

async function checkUpdate() {
  const response = await fetch(
    "http://localhost:9000/checkVersion?app_name=appName&version=0.0.1&channel=stable&platform=linux&arch=amd64&owner=admin"
  );
  const data = await response.json();
  console.log(data);
}

checkUpdate();

This will return information about the latest version, available updates, and changelogs for your app.

If you try faynoSync, I’d love to hear your feedback — open an issue, suggest a feature, or star the project on GitHub. Your support keeps it alive and growing 💚

I Built faynoSync: A Self-Hosted API for Automatic App Updates

Serhii Kuianov — Mon, 01 Sep 2025 10:58:24 +0000

In today’s fast-paced world of AI and software development, more and more people and companies are creating their own applications. You might publish them on platforms like Google Play, the App Store, or use GitHub Releases for desktop apps. These platforms handle versioned updates automatically—but there’s a catch: bureaucracy, registrations, and endless hoops before your app goes live.

Think about it — where do you actually download apps like Discord, Brave, or Docker Desktop? Usually not through app stores.

I built faynoSync to make this simple.

What is faynoSync?

faynoSync is a lightweight, open-source API server that gives you full control over your application updates. It works for desktop software, mobile apps, browser extensions, or custom binaries for metrics or monitoring.

No external dependencies. Just your server, your updates, and complete control.

Why I Built faynoSync

Every language and OS has its own update tools, but they’re often non-transparent, overly complex, or hard to integrate.

faynoSync is universal — you can check for updates from any language with a centralized API and minimal setup.

What faynoSync Can Do

🔓 Create public or private applications
🔐 Support signed and unsigned builds (perfect for dev environments)
👥 Manage team users and assign fine-grained permissions
🚀 Publish, roll back, or deactivate specific releases
⚠️ Mark applications as critical to notify users immediately
🌍 Manage channels (dev, prod, nightly, stable), platforms, and architectures
📝 Add, edit, and display changelogs
📊 Optionally collect and display anonymous usage statistics — see which app versions, channels, and platforms are most popular
🛠️ Support multiple updaters such as Squirrel, Electron Builder, and others
⚡ Built with Go — fast, simple, open-source

…and it’s only the start. More features are coming.