Serhii Kuianov

Want to know how your users are using your application? Need insights into version adoption and platform distribution? Meet Telemetry Insights — your window into user behavior and application usage!

What is Telemetry? 🤔​

Telemetry is your application's built-in analytics system that:

• 📈 Tracks user engagement
• 🔍 Monitors version distribution
• 🌍 Analyzes platform usage
• 📊 Provides valuable insights

It helps you make data-driven decisions about your application's future!

What You Can Track 🎯​

1. User Analytics​

• 👥 Total unique users
• 🔄 Daily active users
• 📱 Platform distribution
• 💻 Architecture breakdown

2. Version Insights​

• 📦 Version adoption rates
• ⚡ Update patterns
• 🎯 Outdated version tracking
• 📈 Version distribution trends

3. Channel Analytics​

• 🎨 Channel popularity
• 📊 User preferences
• 🔄 Update frequency
• 🎯 Channel-specific insights

How to Enable It? 🔌​

Just add this to your .env file:

ENABLE_TELEMETRY=true

That's it! Your application will start collecting valuable insights automatically.

What Data is Collected? 📝​

Essential Metrics​

1. Device Information 📱

   • Platform (Windows, macOS, Linux, etc.)
   • Architecture (x64, arm64, etc.)
   • Channel (stable, beta, nightly)

2. Version Data 📦

   • Current version
   • Update frequency
   • Version adoption rates

3. Usage Patterns 📊

   • Daily active users
   • Update check frequency
   • Channel preferences

Privacy First 🔒​

What We Don't Collect​

• ❌ Personal information
• ❌ IP addresses
• ❌ Sensitive data
• ❌ User behavior outside the app

Security Measures​

• 🔐 Anonymous device IDs
• 📅 30-day data retention
• 👥 Admin and team access (admin can only see their own apps' stats)

How to Access Insights? 📊​

Dashboard View​

1. Log in to your admin dashboard
2. Navigate to the Telemetry section
3. Explore your insights!

API Access​

GET /telemetry?range=week

Available filters:

• 📅 Date range
• 📦 Application
• 🎨 Channel
• 📱 Platform
• 💻 Architecture

Best Practices 💡​

1. Early Implementation 🚀

   • Enable telemetry from day one
   • Track version adoption
   • Monitor user engagement

2. Regular Analysis 📊

   • Review weekly reports
   • Track version distribution
   • Monitor platform usage

3. Data-Driven Decisions 🎯

   • Use insights for updates
   • Optimize for popular platforms
   • Focus on user preferences

Example Insights 📈​

Here's what you might discover:

• 75% of users are on the latest version
• Most popular platform: Windows (40%)
• Highest engagement: Beta channel
• Most popular architecture: x64 (45%)
• Top 3 versions in use:
  • v1.2.0: 35%
  • v1.1.0: 25%
  • v1.0.0: 15%
• Client trends:
  • Growing user base
  • Latest version adoption
  • Outdated clients
• API usage:
  • Total version check requests

How to try faynoSync?​

1. Follow the Getting Started guide:
   👉 https://ku9nov.github.io/faynoSync-site/docs/category/getting-started

2. Create your app using the REST API or web dashboard:
   📦 API Docs: https://ku9nov.github.io/faynoSync-site/docs/api
   🖥️ Dashboard UI: https://github.com/ku9nov/faynoSync-dashboard

3. Enable telemetry in your .env file

4. Start collecting valuable insights! 📊

If you find this project helpful, please consider subscribing, leaving a comment, or giving it a star, create Issue or feature request on GitHub.
Your support keeps the project alive and growing 💚

Today, we'll explore how to create a simple Electron app and add auto-update functionality using faynoSync. Let's make your app smarter with automatic version checking and updates!

Prerequisites 📋​

Before we begin, make sure you have:

• A running faynoSync instance
• Published versions 0.0.1 and 0.0.2 of your app
• Created an app in faynoSync named "myapp"
• Created a channel in faynoSync named "nightly"
• Created a platform in faynoSync named (darwin/linux/windows)
• Created a architecture in faynoSync named (amd64/arm64)

Let's Get Started! 🚀​

1. Initialize Your Project​

First, let's create a new project with the following package.json:

{
  "name": "myapp",
  "version": "0.0.1",
  "description": "Hello world app for testing faynoSync",
  "main": "main.js",
  "scripts": {
    "start": "electron ."
  },
  "keywords": [],
  "author": "Example Author",
  "license": "ISC",
  "dependencies": {
    "node-fetch": "2.6.9"
  },
  "devDependencies": {
    "electron": ">=23.3.13"
  },
  "engines": {
    "npm": ">=8.19.3",
    "node": ">=18.13.0"
  }
}

2. Create Basic Files​

index.html​

<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <title id="title"></title>
</head>
<body>
  <h1 id="label">Hello, world!</h1>
</body>
</html>

config.js​

const packageJson = require('./package.json');

module.exports = {
  app_name: packageJson.name,
  version: packageJson.version,
  channel: "nightly",
  owner: "example",
};

The Magic of Auto-Updates ✨​

Let's create our main.js file step by step:

1. Import Required Modules​

const { app, BrowserWindow, dialog, shell } = require('electron');
const fetch = require('node-fetch');
const os = require('os');
const { version, app_name, channel, owner } = require('./config.js');
const fs = require('fs');

2. Platform Detection​

function getLinuxDistributionFamily() {
  let distroFamily = 'Linux';
  try {
    const releaseInfo = fs.readFileSync('/etc/os-release', 'utf8');
    const match = releaseInfo.match(/^ID(?:_LIKE)?=(.*)$/m);
    if (match) {
      const idLike = match[1].trim().toLowerCase();
      if (idLike.includes('rhel') || idLike.includes('fedora') || idLike.includes('centos')) {
        distroFamily = 'RHEL';
      } else if (idLike.includes('debian') || idLike.includes('ubuntu') || idLike.includes('kali')) {
        distroFamily = 'Debian';
      }
    }
  } catch (err) {
    console.error('Error getting Linux distribution family:', err);
  }
  return distroFamily;
}

3. Update Choice Window​

function createChoiceWindow(updateOptions) {
  const win = new BrowserWindow({
    width: 600,
    height: 400,
    webPreferences: {
      nodeIntegration: true,
    },
  });

  win.loadURL(`data:text/html,
    <html>
      <body>
        <h2>Choose an update package:</h2>
        <ul>
          ${updateOptions
            .map(
              (option, index) =>
                `<li><a id="option-${index}" href="${option.url}">${option.name}</a></li>`
            )
            .join('')}
        </ul>
        <script>
          const { shell } = require('electron');
          document.addEventListener('click', (event) => {
            if (event.target.tagName === 'A') {
              event.preventDefault();
              shell.openExternal(event.target.href);
            }
          });
        </script>
      </body>
    </html>`
  );

  return win;
}

4. Update Check Function​

function checkUpdates() {
  let url = `http://localhost:9000/checkVersion?app_name=${app_name}&version=${version}&platform=${os.platform()}&arch=${os.arch()}&owner=${owner}`;

  if (channel !== undefined) {
    url += `&channel=${channel}`;
  }

  fetch(url, { method: 'GET' })
    .then((res) => res.json())
    .then((data) => {
      console.log(data);
      if (data.update_available) {
        const message = `You have an older version. Would you like to update your app?`;
        dialog.showMessageBox({
          type: 'question',
          title: 'Update available',
          message: message,
          buttons: ['Yes', 'No'],
          defaultId: 0,
        }).then(({ response }) => {
          if (response === 0) {
            const updateOptions = [];
            for (const key in data) {
              if (key.startsWith('update_url_')) {
                updateOptions.push({ name: key.substring(11).toUpperCase(), url: data[key] });
              }
            }
            const choiceWindow = createChoiceWindow(updateOptions);
          }
        });
      }
    })
    .catch(() => {});
}

5. Main Window Creation​

function createWindow() {
  let osName = os.platform();
  let pcArch = os.arch();
  if (osName === 'linux') {
    osName = getLinuxDistributionFamily();
  }
  const title = `${app_name} - v${version} (${osName}-${pcArch})`;

  let win = new BrowserWindow({
    width: 400,
    height: 300,
    webPreferences: {
      nodeIntegration: true,
    },
  });

  win.setTitle(title);
  win.loadFile('index.html');
  win.on('closed', () => {
    win = null;
  });

  checkUpdates();
}

app.whenReady().then(createWindow);

Running Your App 🏃‍♂️​

To start your app, simply run:

npm start

If everything is set up correctly in faynoSync and a newer version exists, you'll see something like this in your logs:

{
  "critical": false,
  "update_available": true,
  "update_url_dmg": "http://localhost:9010/cb-faynosync-s3-public/myapp-example/nightly/darwin/arm64/myapp-0.0.2.0.dmg"
}

And in your app's UI, you'll see a notification about the available update. After agreeing to update, you can download and install the new version.

Next Steps 🚀​

1. Customize the update process to match your app's needs
2. Add more sophisticated update handling
3. Implement your own update installation logic
4. Add progress indicators for downloads

Need Help? 🤝​

If you have any questions or need assistance:

1. Check out our documentation
2. Create an issue on GitHub

How to try faynoSync?​

1. Follow the Getting Started guide:
   👉 https://ku9nov.github.io/faynoSync-site/docs/category/getting-started

2. Create your app using the REST API or web dashboard:
   📦 API Docs: https://ku9nov.github.io/faynoSync-site/docs/api
   🖥️ Dashboard UI: https://github.com/ku9nov/faynoSync-dashboard

3. Upload at least two versions of your application.

4. Check for updates with this simple request:
   📡 /info/latest

If you find this project helpful, please consider subscribing, leaving a comment, or giving it a star, create Issue or feature request on GitHub.
Your support keeps the project alive and growing 💚

Is your faynoSync instance handling thousands of update checks per minute? Worried about database load? Meet Performance Mode — your API's new best friend for handling high traffic efficiently!

What is Performance Mode? 🤔​

Performance Mode is a smart caching system that:

• 🚀 Reduces response times
• 📉 Lowers database load
• 💾 Optimizes resource usage

It works by caching frequently requested data in Redis, making your API responses lightning-fast!

How It Works 🛠️​

The Magic Behind the Scenes​

1. Request Arrives 📥

   • API checks if Performance Mode is enabled (PERFORMANCE_MODE=true)
   • Looks for cached data in Redis

2. Cache Check 🔍

   • If data exists in cache → returns it immediately
   • If not → queries the database

3. Cache Update 💾

   • New data is stored in Redis
   • Ready for next request

What Gets Cached?​

Currently, Performance Mode is implemented for the checkVersion endpoint, which is one of the most frequently called endpoints in the system.

Why Do We Need It? 🎯​

1. Database Load Reduction​

• 📊 Fewer queries to MongoDB
• 💪 Less strain on your database
• 🎯 Better resource utilization

2. Faster Response Times​

• ⚡ Cached responses are returned instantly
• 🏎️ No need to wait for database queries
• 🎮 Perfect for high-traffic scenarios

3. Resource Optimization​

• 🌱 Lower CPU usage
• 💧 Reduced memory consumption
• 📈 Better scalability

How to Enable It? 🔌​

Just add this to your .env file:

PERFORMANCE_MODE=true

That's it! Your API will automatically start using Redis for caching.

Testing Performance 🧪​

Want to see the difference? Try this test script:

start_time=$(date +%s); 
for i in {1..1000}; do 
  response=$(curl -s -w "Connect Time: %{time_connect}s, Start Transfer Time: %{time_starttransfer}s, Total Time: %{time_total}s\n" -o /dev/stdout --location 'http://localhost:9000/checkVersion?app_name=myapp&version=0.0.3&channel=nightly&platform=null&arch=null'); 
  echo "$response"; 
done; 
end_time=$(date +%s); 
total_time=$((end_time - start_time)); 
echo "Total execution time: $total_time seconds"

Compare the results with and without Performance Mode enabled!

Important Notes 📝​

1. Cache Invalidation 🔄

   • Cache is automatically cleared when you publish a new version
   • New data is cached on the next request
   • Ensures users always get the latest information

2. Current Implementation 🎯

   • Only implemented for checkVersion endpoint
   • Perfect for high-frequency update checks
   • More endpoints might be added in the future

3. When to Use ⚡

   • High-traffic environments
   • Systems with frequent update checks
   • Scenarios where response time is critical

Best Practices 💡​

1. Enable in Production 🚀

   • Always use Performance Mode in production
   • Especially if you expect high traffic

2. Monitor Performance 📊

   • Keep an eye on response times
   • Watch Redis memory usage
   • Track database load

3. Regular Updates 🔄

   • Cache is automatically managed
   • No manual intervention needed
   • Just focus on your app!

How to try faynoSync?​

1. Follow the Getting Started guide:
   👉 https://ku9nov.github.io/faynoSync-site/docs/category/getting-started

2. Create your app using the REST API or web dashboard:
   📦 API Docs: https://ku9nov.github.io/faynoSync-site/docs/api
   🖥️ Dashboard UI: https://github.com/ku9nov/faynoSync-dashboard

3. Upload at least two versions of your application.

4. Check for updates with this simple request:
   📡 /info/latest

If you find this project helpful, please consider subscribing, leaving a comment, or giving it a star, create Issue or feature request on GitHub.
Your support keeps the project alive and growing 💚

Ever needed to share a download link that always points to the latest version of your app? Or wanted to set up automatic updates for your users? The Fetch latest version of app endpoint is your perfect solution! Let's explore how it works with some real-world examples.

Meet Our Example App 🎮​

Let's imagine we have an app called "SpaceExplorer" with the following setup:

Channels:​

• 🚀 stable - Production releases
• 🧪 beta - Testing versions
• 🌙 nightly - Daily builds

Platforms & Architectures:​

• 💻 Linux (amd64, arm64)
• 🍎 macOS (amd64, arm64)
• 🪟 Windows (amd64)

Package Types:​

• 📦 .deb (Linux)
• 📦 .rpm (Linux)
• 📦 .dmg (macOS)
• 📦 .exe (Windows)

Let's Fetch Some Versions! 🎯​

Example 1: Simple Latest Version​

GET /apps/latest?app_name=SpaceExplorer&owner=admin

This basic request returns ALL available builds:

{
    "stable": {
        "linux": {
            "amd64": {
                "deb": { "url": "..." },
                "rpm": { "url": "..." }
            },
            "arm64": {
                "deb": { "url": "..." },
                "rpm": { "url": "..." }
            }
        },
        "darwin": {
            "amd64": { "dmg": { "url": "..." } },
            "arm64": { "dmg": { "url": "..." } }
        },
        "windows": {
            "amd64": { "exe": { "url": "..." } }
        }
    },
    "beta": {
        // Similar structure for beta builds
    },
    "nightly": {
        // Similar structure for nightly builds
    }
}

Example 2: Specific Channel​

GET /apps/latest?app_name=SpaceExplorer&channel=stable&owner=admin

Now we get only stable builds:

{
    "stable": {
        "linux": {
            "amd64": {
                "deb": { "url": "..." },
                "rpm": { "url": "..." }
            }
            // ... other architectures
        }
        // ... other platforms
    }
}

Example 3: Platform-Specific​

GET /apps/latest?app_name=SpaceExplorer&channel=stable&platform=linux&owner=admin

Only Linux builds:

{
    "stable": {
        "linux": {
            "amd64": {
                "deb": { "url": "..." },
                "rpm": { "url": "..." }
            },
            "arm64": {
                "deb": { "url": "..." },
                "rpm": { "url": "..." }
            }
        }
    }
}

Example 4: Exact Match​

GET /apps/latest?app_name=SpaceExplorer&channel=stable&platform=linux&arch=amd64&package=deb&owner=admin

This returns a direct download URL:

https://<bucket_name>.s3.amazonaws.com/SpaceExplorer/stable/linux/amd64/SpaceExplorer-1.2.3.deb

Smart Features 🧠​

1. Automatic Redirection 🔄

   • If only one build matches your criteria, you'll get redirected straight to the download
   • Perfect for landing pages and direct download links

2. Flexible Responses 🎯

   • Get all available builds
   • Filter by channel
   • Filter by platform
   • Filter by architecture
   • Filter by package type

Real-World Use Cases 🌍​

1. Landing Page Downloads​

<!-- For Linux users -->
<a href="/apps/latest?app_name=SpaceExplorer&platform=linux&arch=amd64&package=deb&owner=admin">
    Download for Linux (.deb)
</a>

<!-- For macOS users -->
<a href="/apps/latest?app_name=SpaceExplorer&platform=darwin&arch=arm64&package=dmg&owner=admin">
    Download for macOS (.dmg)
</a>

2. Team Testing​

# For beta testers
GET /apps/latest?app_name=SpaceExplorer&channel=beta&platform=darwin&arch=arm64&package=dmg&owner=admin

# For nightly build enthusiasts
GET /apps/latest?app_name=SpaceExplorer&channel=nightly&platform=linux&arch=amd64&package=deb&owner=admin

What's Next? 🚀​

In our next posts, we'll explore:

• Performance optimization tips

Stay tuned for more faynoSync tips and tricks! 💚

How to try faynoSync?​

1. Follow the Getting Started guide:
   👉 https://ku9nov.github.io/faynoSync-site/docs/category/getting-started

2. Create your app using the REST API or web dashboard:
   📦 API Docs: https://ku9nov.github.io/faynoSync-site/docs/api
   🖥️ Dashboard UI: https://github.com/ku9nov/faynoSync-dashboard

3. Upload at least two versions of your application.

4. Check for updates with this simple request:
   📡 /info/latest

If you find this project helpful, please consider subscribing, leaving a comment, or giving it a star, create Issue or feature request on GitHub.
Your support keeps the project alive and growing 💚

Getting started with faynoSync development? Great! You have two main options for setting up your local environment. Whether you prefer a traditional local setup or the convenience of Docker, we've got you covered.

Option 1: Traditional Local Development 🖥️​

Perfect for developers who want full control over their environment and need to make frequent code changes.

What You'll Need:​

• MongoDB 🗄️

  • Stores all your application data, versions, and metadata
  • Installation Guide

• Golang 🐹

  • The heart of faynoSync
  • Installation Guide

• MinIO 📦

  • Your local S3-compatible storage
  • Installation Guide

Setting Up:​

1. Install all required services
2. Create your .env file with necessary configurations
3. Run faynoSync:

   # First run (with migrations)
   go run faynoSync.go --migration
   
   # Subsequent runs
   go run faynoSync.go
   

Benefits:​

• ⚡ Fast development cycle
• 🔧 Direct access to all components
• 🧪 Easy debugging
• 🔄 Quick code changes

Testing Your Setup:​

Want to make sure everything is working correctly? Just run:

go test

This will verify that all components are properly configured and your local environment is ready for development.

Option 2: Docker Development 🐳​

Ideal for quick setup and testing, or when you want to avoid installing dependencies locally.

What You'll Need:​

• Docker 🐳
  • Installation Guide
• Docker Compose 🎵
  • Installation Guide

Two Ways to Use Docker:​

1. Full Container Setup​

docker-compose up --build

Perfect for:

• 🚀 Quick testing
• 🧪 Initial setup
• 🔄 Testing API functionality

2. Hybrid Approach​

docker-compose -f docker-compose.yaml -f docker-compose.development.yaml up

This starts only the dependencies (MongoDB and MinIO) while you run faynoSync locally.

Benefits:​

• 🚀 Quick setup
• 🧩 Isolated environment
• 🔄 Consistent across machines
• 🧪 Easy testing

Testing Your Setup:​

After running docker-compose up --build, wait until the s3-service successfully creates the bucket, then run:

docker exec -it faynoSync_backend "/usr/bin/faynoSync_tests"

This will run the test suite inside the container to verify everything is working correctly.

Environment Configuration ⚙️​

Both approaches need proper environment configuration. Here are the key variables you'll need:

# Storage Configuration
STORAGE_DRIVER=minio
S3_ACCESS_KEY=your_access_key
S3_SECRET_KEY=your_secret_key
S3_BUCKET_NAME=your_bucket

# Database Configuration
MONGODB_URL=mongodb://root:password@127.0.0.1/faynosync_db

# API Configuration
API_URL=http://localhost:9000
PORT=9000

For a complete list of environment variables, check out our Environment Configuration Guide.

Which Option Should You Choose? 🤔​

Choose Local Development if you:​

• 🔧 Need to modify the code frequently
• 🐛 Want to debug easily
• ⚡ Need fast development cycles
• 💻 Prefer direct control over your environment

Choose Docker if you:​

• 🚀 Want quick setup
• 🧪 Need to test the API
• 💻 Work on multiple machines
• 🧩 Prefer isolated environments

What's Next? 🚀​

In our next posts, we'll explore:

• How to properly use Fetch latest version of app request
• Performance optimization tips

Stay tuned for more faynoSync tips and tricks! 💚

How to try faynoSync?​

1. Follow the Getting Started guide:
   👉 https://ku9nov.github.io/faynoSync-site/docs/category/getting-started

2. Create your app using the REST API or web dashboard:
   📦 API Docs: https://ku9nov.github.io/faynoSync-site/docs/api
   🖥️ Dashboard UI: https://github.com/ku9nov/faynoSync-dashboard

3. Upload at least two versions of your application.

4. Check for updates with this simple request:
   📡 /info/latest

If you find this project helpful, please consider subscribing, leaving a comment, or giving it a star, create Issue or feature request on GitHub.
Your support keeps the project alive and growing 💚

Managing a team of developers? Need to control who can do what in your faynoSync instance? Starting from version 1.4.0, faynoSync introduces a powerful Team Based Authorization Matrix that gives you complete control over your team's access and permissions.

What is Team-Based Authorization? 🤔​

Think of it as your team's digital headquarters! The Team Based Authorization Matrix is a sophisticated system that lets you:

• 👨‍💼 Create and manage team users
• 🔐 Assign specific permissions
• 🏢 Keep data isolated between different teams
• 📊 Track who can do what

Meet the Players 🎭​

The Administrator 👑​

• You're the boss! Each admin is unique
• You own your team of users
• You can create, update, and delete your team members
• You have full control over passwords and permissions
• You can only access your own team's resources

The Team User 👤​

• A unique member of your team
• Belongs only to you (their admin)
• Can't manage other users
• Can only work with resources you've allowed
• Everything they create belongs to you

What Can Your Team Do? 🛠️​

Each team member can have different permissions for different types of resources:

Resource Types:​

• 📱 Applications
• 📊 Channels
• 💻 Platforms
• 🏗️ Architectures

Available Permissions:​

• ➕ Create
• ✏️ Edit
• 🗑️ Delete
• ⬆️ Upload (for apps)
• ⬇️ Download (for apps)

Smart Resource Management 🧠​

• 🔒 Team users can only see and use resources they've been given access to
• 🏢 Each admin's resources are completely separate
• 👀 You (as admin) can see everything your team creates
• 📝 Different teams can have resources with the same names

How to Manage Your Team? 🎯​

Option 1: Using the API​

Creating 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
    }
  }'

Updating 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
    }
  }'

Option 2: Using the Web Dashboard 🖥️​

Prefer a more visual approach? The faynoSync dashboard makes team management a breeze!

For Administrators:​

1. Click the Settings button in the dashboard
2. A modal window will open where you can:
   • 👥 Create new team users
   • 🔑 Set passwords (or auto-generate them)
   • ✅ Assign permissions with simple checkboxes
   • ✏️ Update usernames and passwords
   • 🗑️ Remove team users

For Team Users:​

1. Go to your Profile section
2. View your current permissions at a glance:
   • 📱 Which applications you can access
   • 📊 What actions you can perform
   • 🔒 What resources are available to you

This visual interface makes it much easier to:

• 🎯 Understand your permissions
• 🔄 Manage team access
• 📊 Track resource availability
• ⚡ Make quick changes

What's Next? 🚀​

In our next posts, we'll explore:

• Local development and deployment to server
• How to properly use Fetch latest version of app request

Stay tuned for more faynoSync tips and tricks! 💚

How to try faynoSync?​

1. Follow the Getting Started guide:
   👉 https://ku9nov.github.io/faynoSync-site/docs/category/getting-started

2. Create your app using the REST API or web dashboard:
   📦 API Docs: https://ku9nov.github.io/faynoSync-site/docs/api
   🖥️ Dashboard UI: https://github.com/ku9nov/faynoSync-dashboard

3. Upload at least two versions of your application.

4. Check for updates with this simple request:
   📡 /info/latest

If you find this project helpful, please consider subscribing, leaving a comment, or giving it a star, create Issue or feature request on GitHub.
Your support keeps the project alive and growing 💚

When developing software, sometimes you need to keep things private. Whether it's internal tools, beta versions, or enterprise applications — not everything should be publicly accessible. That's why faynoSync comes with built-in support for private applications.

What are Private Apps? 🤔​

Private apps in faynoSync are applications that are stored in a separate, private S3 bucket. This gives you an extra layer of security and control over who can access your software.

Once an app is marked as private, it stays private forever — this is a one-way decision to ensure consistency and security.

How to Create a Private App? 🛠️​

There are two ways to create a private app:

1. Using the Web Dashboard 🖥️​

Simply check the "Private" option when creating your app through the dashboard interface. It's that simple!

2. Using the API 📡​

When making a POST request to /app/create, include the private parameter:

curl --location 'http://localhost:9000/app/create' \
--header 'Authorization: Bearer <jwt_token>' \
--form 'data="{\"app\":\"appName\", \"private\": true}"'

How Private Apps Work? 🔐​

1. Storage: Private apps are stored in a separate S3 bucket (defined by S3_BUCKET_NAME in your environment)
2. Access Control: You can control who can download your private apps through the ENABLE_PRIVATE_APP_DOWNLOADING setting:
   • If true: Anyone can download the app using the public API endpoints
   • If false: Only authenticated users can download the app

Security Features 🛡️​

Think of private apps in faynoSync as your software's VIP section! Here's what makes them special:

• 🔒 Separate Storage: Your private apps live in their own secure S3 bucket, like having a private vault for your most valuable assets
• 🔐 One-Way Privacy: Once you mark an app as private, it stays private forever. This might sound strict, but it's actually a good thing — it ensures your security settings can't be accidentally changed
• 👥 Smart Access Control: You're in charge! You can decide whether your private apps need authentication to download, giving you perfect control over who gets access
• 🚫 Download Protection: Want to make sure only your team can download the app? Just set ENABLE_PRIVATE_APP_DOWNLOADING=false, and only authenticated users will be able to access it

Best Practices 💡​

1. Use private apps for:

   • Internal tools and utilities
   • Beta versions of your software
   • Enterprise-specific applications
   • Software requiring license validation

2. Set ENABLE_PRIVATE_APP_DOWNLOADING=false when you need strict access control

3. Always use authentication tokens when accessing private apps in restricted mode

What's Next? 🚀​

In our next posts, we'll explore:

• Local development and deployment to server
• Managing user access and permissions
• How to properly use Fetch latest version of app request

Stay tuned for more faynoSync tips and tricks! 💚

How to try faynoSync?​

1. Follow the Getting Started guide:
   👉 https://ku9nov.github.io/faynoSync-site/docs/category/getting-started

2. Create your app using the REST API or web dashboard:
   📦 API Docs: https://ku9nov.github.io/faynoSync-site/docs/api
   🖥️ Dashboard UI: https://github.com/ku9nov/faynoSync-dashboard

3. Upload at least two versions of your application.

4. Check for updates with this simple request:
   📡 /info/latest

If you find this project helpful, please consider subscribing, leaving a comment, or giving it a star, create Issue or feature request on GitHub.
Your support keeps the project alive and growing 💚

In today's fast-paced world of AI and digitalization, more and more people, companies, and startups are creating their own applications. Depending on the type of app, you might publish it on platforms like Google Play, the App Store, and so on. These services not only handle publishing but also provide automatic versioned updates to end users.

But there's a small catch.

Bureaucracy. Registrations. The 9 circles of hell you have to go through before your app finally goes live on those platforms.
Just think — where do you actually download apps like Discord, Brave Browser, or Docker Desktop?
Exactly. The list goes on.

That's where faynoSync comes in.

What is faynoSync?​

faynoSync is a lightweight, open-source API server that gives you full control over application updates. Whether it's desktop software, mobile apps, browser extensions, or custom binaries for metrics or monitoring — faynoSync helps you deliver updates easily, securely, and reliably.

No external dependencies. Just pure control.

Why faynoSync?​

Sure, each programming language or OS has its own update tools. But they're often non-transparent, overly complicated, or just a pain to integrate.

faynoSync is a universal solution — it allows you to check for updates from any language, with a centralized API and minimal setup.

What can faynoSync do?​

• 🔓 Create public or private applications
• 🔐 Support signed and unsigned builds (perfect for development 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 so users know what's new
• ⚡ Built with Go — fast, simple, and open-source

And it's only the start; there will be more in the future.

How to try faynoSync?​

1. Follow the Getting Started guide:
   👉 https://ku9nov.github.io/faynoSync-site/docs/category/getting-started

2. Create your app using the REST API or web dashboard:
   📦 API Docs: https://ku9nov.github.io/faynoSync-site/docs/api
   🖥️ Dashboard UI: https://github.com/ku9nov/faynoSync-dashboard

3. Upload at least two versions of your application.

4. Check for updates with this simple request:
   📡 /info/latest

This article is just an introduction. In the next posts, we'll explore the full functionality of faynoSync, integration examples, and development tips.

If you find this project helpful, please consider subscribing, leaving a comment, or giving it a star, create Issue or feature request on GitHub.
Your support keeps the project alive and growing 💚