Discover Golang Projects on Upwork with Vollna

I am looking for a highly experienced Senior Blockchain Developer with strong Full-Stack skills and deep expertise in Web3 and Solana development.

Responsibilities:

Develop and optimize Solana smart contracts (Rust)

Build and maintain Web3 integrations, wallet connections, and blockchain APIs

Create full-stack dApps using React, Next.js, Node.js, TypeScript

Work on SPL tokens, NFTs, staking platforms, or other on-chain features

Troubleshoot issues, fix bugs, and improve performance

Collaborate on architecture, planning, and secure development practices

Requirements:

Proven experience as a Senior Blockchain Developer

Strong knowledge of Solana and Rust

Experience with Web3.js, Anchor, or similar frameworks

Full-stack development skills (React/Next.js + Node.js)

Ability to write clean, scalable, and secure code

Good communication and timely delivery

Nice to Have:

Experience with other blockchains (Ethereum, Polygon, etc.)

Knowledge of DevOps or cloud deployment

Project Scope:

You will help build and enhance blockchain-based features for our platform, including smart contracts, Web3 integrations, and dApp functionality.

If you enjoy building resilient automation solutions and designing seamless API integrations for real-world business challenges, this role is for you!

Join us to work with modern technologies like Golang, Temporal.io, and OpenTelemetry while creating scalable systems that power telecommunications service delivery.

What we do
We're building an internal platform for a telecommunications service provider that streamlines network service management and service delivery processes. Our solution exposes APIs and leverages Temporal workflows to handle asynchronous tasks, with comprehensive observability through OpenTelemetry, Grafana, Prometheus, and Tempo.

Your responsibilities
- Architect and develop automation solutions for telecommunications service management.
- Design and optimize APIs for seamless system integration.
- Leverage orchestration tools like Temporal.io to build scalable, resilient workflows.
- Implement and maintain observability using OpenTelemetry with Grafana, Prometheus, and Tempo.
- Troubleshoot and debug distributed systems across service boundaries.
- Ensure comprehensive documentation for automation, API design, and system integrations.

Our requirements
- Strong expertise in Golang, including concurrency patterns, error handling, and API development.
- Experience designing and implementing RESTful APIs and asynchronous messaging systems.
- Proficiency with observability tools and metrics collection (OpenTelemetry, Prometheus, or similar).
- Strong debugging and problem-solving skills for distributed systems.
- Familiarity with performance profiling and optimization techniques in Go.
- Experience with containerization using Docker and container-based development workflows.
- Ability to work in cross-functional teams and communicate effectively with stakeholders.
- Experience with test-driven development and writing maintainable, well-tested code.

Nice to have
- Experience with workflow orchestration systems like Temporal or Cadence.
- Knowledge of telecommunications domain.
- Ability to mentor engineers and drive best practices in software architecture.
- Understanding of OpenAPI/Swagger standards.
- Experience with infrastructure as code and CI/CD pipelines.
- Experience with cloud services (AWS, GCP, or Azure).
- Understanding of networking protocols and service mesh technologies.
- Experience with Kubernetes.

What we offer
- Fully Remote Work Model with flexible scheduling.
- Opportunity to work with cutting-edge technologies (Go, Temporal, OpenTelemetry).
- Collaborative environment with experienced developers.
- Modern development practices and tools.
- Competitive salary.
- Benefits include a Multisport card and private healthcare.

Skills: Software Architecture, Golang, Debugging, Docker, Documentation, Kubernetes, API Development, CI/CD, Distributed Systems

MesoPay – Full Technical Specification & Security Requirements

Software Development Request Document

1. Project Overview

MesoPay is a premium Iraqi fintech application designed for instant domestic transfers and international remittances to Turkey, Jordan, and the UAE.
The platform must reflect reliability, speed, simplicity, and bank-grade security.
Brand colors must follow a premium identity:

Dark Royal Blue (#0E1F40)

Gold (#D9A441)

2. Core Features
A. Authentication

Phone number login

OTP verification

Device binding (account tied to device)

PIN code inside the app

Biometric authentication for transfers

B. KYC Verification

Capture personal information

Upload ID documents (front & back)

Selfie + liveness detection

KYC review dashboard for admins

Return results: pending / verified / rejected

C. Wallet System

Real-time wallet balance

Add balance (top-up)

Withdraw balance to a bank account

Double-entry accounting ledger

Limits based on KYC level

D. Internal Transfers (Domestic)

Instant transfers between users

Search by phone or MesoID

Real-time notifications

Full compliance data stored

E. International Transfers

Supported corridors: Turkey, Jordan, UAE

Automatic FX calculation

Fee calculation

Beneficiary management

Integration with external partners (API + Webhooks)

F. Transaction History

Filters by type

Transaction details

Ledger entries included

G. Notifications Center

Incoming/outgoing transfers

System notifications

Mark-as-read

H. Merchant Dashboard

Merchant profile

View collected payments

Withdrawal requests

Export reports

3. UI/UX Requirements

Premium fintech identity

Full Figma UI/UX delivery

Arabic (RTL) and English support

All core actions reachable within 2–3 taps

Clean layouts, strong hierarchy, minimalistic design

Required Screens:
Splash, Welcome, Phone Input, OTP, Home, Add Balance, Withdraw, Internal Transfer, International Transfer, Beneficiary Setup, Transaction History, Notifications, Profile, KYC, Merchant Dashboard, Settings, Success/Error screens.

4. Mobile App Requirements (Flutter)

Development in Flutter (Android + iOS)

State management: Bloc or Riverpod

Clean Architecture structure

Secure local storage

App integrity checks (anti-root, anti-jailbreak)

Screen recording blocked on sensitive pages

5. Backend Architecture
Recommended Technology Stack

Node.js (NestJS) or GoLang

PostgreSQL (main database)

Redis (cache + rate limiting)

Message Queue: Redis Streams or RabbitMQ

S3 storage for documents

JWT authentication

Separation of services (modular or microservices)

Core Backend Services

Authentication Service

User & KYC Service

Wallet & Ledger Service

Transfer Engine (Domestic & International)

FX & Fee Engine

Notification Service

Fraud & Risk Engine

Admin Panel Backend

6. Database Schema (Key Tables)

users

otp_codes

user_devices

kyc_profiles

wallets

ledger_entries

transfers

beneficiaries

notifications

audit_logs

fraud_flags

merchants

merchant_settlements

7. Transfer Engine Logic
Domestic Transfers

Validate sender & recipient

Check available balance

Perform double-entry ledgering

Create immutable audit log

Capture device + IP + KYC data

Notify both users instantly

Store data for a minimum of 5 years

International Transfers

Get FX rate

Calculate fees

Deduct balance via ledger

Send request to external partner

Update status through partner webhook

Auto-refund on failure

**8. Mandatory Data Requirements

(Domestic + International Compliance)**

Sender Data

Full legal name

Phone number

National ID number

Date of birth

Device ID

IP address during transaction

KYC level

Address (if applicable)

Recipient Data

Full name

Phone number

Country

Account/IBAN (for international transfers)

Transaction Data

Unique Transaction ID (UUID)

Timestamp

Amount

Fees

FX rate

Status

Purpose of transfer

Partner reference (if international)

Risk score

Full ledger trail

Retention Requirements

All records must be stored for 5–10 years

No deletion or modifications allowed

Travel Rule Compliance (for international transfers)

Must include:

Sender name + ID

Recipient name + account

Country of destination

Transfer amount and purpose

9. Highest Security Standards (Bank-Grade Level)
Encryption

TLS 1.3 only

AES-256 encryption

Field-level encryption for sensitive data

Encrypted local storage

Key Management

Hardware-backed keys (HSM/KMS)

Automatic key rotation

Authentication Security

Multi-Factor Authentication (OTP + PIN + Biometrics)

Device binding

Session timeout policies

App Security

SSL Pinning

Anti-reverse engineering

Anti-debugging

Jailbreak/root detection

Integrity checks

Fraud Detection

Behavioral analytics

Velocity checks

Geo-IP anomaly detection

AML red-flag patterns

Suspicious Activity Report (SAR) generation

Audit Logging

Immutable logs

All updates tracked

Combined user + admin log trails

Infrastructure

Private VPC

WAF firewall

Secure CI/CD

Secrets not stored in code

Multi-region backups

DRP with recovery < 60 minutes

10. Admin Panel Requirements
Admin Features

User management

KYC review

Transaction monitoring

AML & fraud dashboard

Transfer control (refund, block, investigate)

FX rate management

System configuration

Exportable reports (CSV/PDF)

11. API Requirements
Authentication

/auth/request-otp

/auth/verify-otp

/auth/refresh

User/KYC

/kyc/submit

/kyc/status

Wallet

/wallet

/wallet/add

/wallet/withdraw

Domestic Transfers

/transfers/internal

International Transfers

/transfers/international

/transfers/quote

History

/transfers/history

Notifications

/notifications

Merchant APIs

/merchant/overview

/merchant/withdraw

Partner Webhooks

/partners/{id}/webhook

Admin APIs

/admin/users

/admin/kyc

/admin/transfers

/admin/reports

12. Required Deliverables from the Software Company

The selected development company must deliver:

Full Flutter mobile apps (Android & iOS)

Complete backend with all services

Admin Panel dashboard

Full Figma UX/UI design

Database schema and ERD

API documentation (Swagger)

Security implementation (bank-grade)

QA testing + penetration testing

Deployment guide + CI/CD

Full source code ownership

13. Final Statement for the Development Company

MesoPay must be built as a bank-grade financial system,
with a non-modifiable ledger, immutable audit logs,
full AML/KYC compliance, Travel Rule support,
and the highest level of encryption and security.
All transaction data—domestic and international—must be stored
for at least 5 years and be fully exportable for regulatory authorities.

Skills: Mobile App Development, Node.js, PostgreSQL, Redis, Blockchain, Backend Development, Security, Database Design, API Development, User Experience Research

For one of our team member, we are seeking an experienced Golang developer with an ability to coach / mentor / guide / teach, in order to setup weekly calls (screen sharing + call) for coaching / mentoring sessions and/or pair programming sessions.
The objective is the general improvement of the team member's Golang development quality, expertise and style.
We are looking for someone with very good english, senior level expertise in development and in Golang and capable of guiding and teaching.

• Do you have experience guiding, mentoring and teaching other developers?
• What is your level of expertise with Golang and in which type of projects have you developed?

Project Title:Build a GA4-Style Analytics Platform Using Go, ClickHouse & AWS

1. Project Overview

I am looking to hire an experienced backend / data engineer or team to build a high-performance analytics pipeline similar to Google Analytics 4 (GA4).
The system should track web/app events, process them in real time, create sessions, store rich analytics data, and serve fast dashboard queries.

The architecture will use:

Eventnative (Go) as the event collector

Golang microservices for sessionization and analytics APIs

ClickHouse as the OLAP storage engine

AWS as the hosting environment (ECS or EKS, MSK/Kafka, EC2, Lambda optional)

The final platform must support millions of events/day with sub-second query performance.

2. Key Objectives
✔ Build a scalable GA4-like tracking backend
✔ Process events in real time (sessionization, identity stitching)
✔ Store analytics data in ClickHouse with optimized schemas
✔ Build a Go-based Query API for dashboards
✔ Deploy fully on AWS with production-grade infrastructure
✔ Provide documentation and CI/CD pipelines
3. High-Level Architecture
Web / App SDKs
↓
Eventnative (Go collector on AWS ECS/EKS)
↓
AWS MSK (Kafka) or SQS/Kinesis
↓
Go Sessionization Worker (ECS/EKS/Lambda)
↓
ClickHouse Cluster (AWS EC2 / Altinity.Cloud / ClickHouse Cloud)
↓
Materialized Views (GA4-style aggregations)
↓
Go Query API (ECS/EKS)
↓
Dashboard (React or BI Tool)

4. Detailed Scope of Work
4.1 Event Collection Layer (Eventnative in Go)

Requirements:

Deploy Eventnative on AWS ECS/EKS

Accept events via /api/v1/event and /api/v1/s2s/event

Support:

page_view

custom events

user identity events

Validate and enrich event payloads

Publish raw events to AWS MSK (Kafka) or Kinesis

Deliverables:

Event collector service

AWS deployment configuration (Terraform optional)

Load-tested ingestion endpoint

4.2 AWS Messaging Layer

You can choose between:

Option A: AWS MSK (Kafka) – Preferred for scale
Option B: AWS Kinesis – Simpler, fully managed
Option C: SQS (for smaller workloads)

Requirements:

High-throughput event buffering

Dead-letter support

Consumer groups for Go workers

Deliverables:

Topics/streams setup

IAM policies

Monitoring dashboards

4.3 Go Worker for Sessionization + Identity

This service turns raw events into GA4-style analytics.

Responsibilities:

Read events from Kafka/Kinesis

Perform sessionization:

Break sessions after 30 minutes idle

Start new session at midnight

Handle campaign/source changes

Identity stitching:

anonymous_id ↔ user_id mapping

Compute:

session_start

session_end

engagement_time

session_index

Deliverables:

Golang microservice (fully documented)

Unit + load tests

AWS ECS/EKS deployment

Error handling + retries

Monitoring via CloudWatch / Prometheus

4.4 ClickHouse Data Warehouse on AWS

You may choose:

Option A: Self-managed EC2 cluster
Option B: ClickHouse Cloud (recommended)
Option C: Altinity.Cloud

Requirements:

Create raw_events table

Create sessionized_events table

Set TTLs, partitions, compression

Optimize for high cardinality

Deliverables:

SQL schema scripts

Optimized partitions (Monthly)

MergeTree engines

Replication + backups

VPC, subnets, SGs

4.5 Materialized Views for Analytics (GA4-like)

The contractor must implement ClickHouse MVs for:

Events reporting

Daily event counts

Event parameters

Unique users per event

User activity

DAU / WAU / MAU

Active users timeline

Sessions

Average session duration

Sessions per user

Engagement metrics

Funnels

Step-based conversions

Drop-off rates

Retention & Cohorts

Day 0 → Day N retention table

Deliverables:

All necessary MVs

Test queries

Performance benchmarks

4.6 Go-Based Query API (Analytics Backend)

This API feeds the dashboard.

Endpoints:

/metrics/events – daily event totals

/metrics/active-users – DAU/WAU/MAU

/metrics/sessions – session aggregates

/metrics/funnels – conversion funnel queries

/metrics/retention – cohort analysis

Authentication + role-based access optional

Deliverables:

Go API (Chi/Fiber/Gin or Echo)

Integrated ClickHouse Go driver

Cache layer (Redis optional)

Swagger / OpenAPI documentation

ECS/EKS deployment

4.7 Optional: Dashboard UI (Web App)

If included in scope.

Tech Stack:

React or Next.js

Tailwind

Chart.js / ECharts

Views:

Overview dashboard

Events explorer

Funnel analysis

Retention cohort view

Session insights

5. Deliverables Summary
Component Deliverable
Event Collection Eventnative deployed on AWS
Messaging Layer Kafka/Kinesis/SQS with DLQs
Go Worker Sessionization + identity service
ClickHouse Raw + sessionized tables, optimized
Materialized Views Fully built GA4-style rollups
Query API Go-based analytics API
Dashboard (optional) UI for metrics
AWS Infra ECS/EKS, VPC, ALB, IAM, CI/CD
Documentation Setup + architecture + code docs
6. Expected Skills

The ideal candidate/team should have strong experience with:

Golang microservices

ClickHouse OLAP design

Kafka/Kinesis streaming systems

AWS ECS/EKS or EC2 deployments

Real-time event ingestion pipelines

High-scale analytics systems

Bonus:

Experience with GA4, Mixpanel, Segment

Experience with Eventnative/Jitsu

7. Project Timeline
Phase 1: Architecture + Setup (Week 1)

AWS infrastructure

ClickHouse cluster

Eventnative base setup

Phase 2: Ingestion Pipeline (Week 2–3)

Collector → Kafka/Kinesis

Raw events ingestion

Load tests

Phase 3: Worker + Sessionization (Week 3–4)

Go worker

Identity management

Session-level validation

Phase 4: ClickHouse Models (Week 5)

Raw/session tables

MVs + performance tuning

Phase 5: Query API (Week 6)

Go API

Authentication

Rate limiting

Phase 6: Dashboard (Optional, Week 7)
Phase 7: Final QA + Deployment (Week 8)
8. What to Include in Your Proposal

Please include:

Relevant past work with Go/Kafka/ClickHouse

Experience building analytics or tracking systems

Estimated timeline

Cost breakdown by phase

AWS infrastructure approach (ECS vs EKS vs Lambda)

Any improvements/suggestions to the architecture

**Job Opportunity: Sports Betting Platform Developer**

We are on the lookout for a talented full stack developer or a team of developers to build an all-encompassing sports betting platform. This exciting project will involve creating features such as user registration, a variety of betting options, real-time odds updates, secure payment processing, and a user-friendly interface.

The perfect candidate will possess a strong background in sports betting platforms development and Familiarity with betting regulations and best security practices is essential. If you have a passion for integrating technology with the sports world, we would be thrilled to connect with you!

Work Description (Technical Requirements)

We are looking to purchase a ready-made (pre-built / white-label), fully-owned remote workforce monitoring and productivity analytics software that can be immediately delivered, customized, and deployed under our ownership.
This is not a request for software development from scratch — we require an existing, stable, enterprise-grade system.

The software must meet the following criteria:

1. Core Functional Requirements

Must detect whether a remote employee is actually working at the computer, even if Microsoft Teams, Slack, Zoom, or similar applications show the user as “active/online.”

Must analyze behavioral activity patterns and trigger alerts when the employee’s activity falls below configurable productivity thresholds.

Must track, verify, and report overtime work requests and actual overtime activity.

Must provide high-accuracy detection of:

Keyboard and mouse activity

Application usage

Idle time vs. productive time

Multi-monitor usage (if applicable)

2. Advanced Monitoring & Anti-Fraud Capabilities

Optional but strongly preferred: Face recognition system that can identify whether the employee truly sits at the computer.

Should detect mask usage or spoof attempts (optional but valuable).

Should prevent or flag manipulations such as:

Auto-clickers

Macro tools

Fake activity generators

Screen looping

3. Performance & Scalability Requirements

The system must support up to 1,000,000 concurrent users with no performance degradation.

Software architecture must be cloud-efficient with minimal server load and optimized operational cost.

Multi-tenant architecture must allow many companies to use the platform simultaneously without impacting one another’s performance.

4. Platform Compatibility

Must run on:

Windows

macOS

iOS

Android

Design must be user-friendly, intuitive, and easily adopted by non-technical users.

5. Administration & User Management

Company administrators must be able to:

Easily create, modify, and deactivate user accounts.

Import/export employee data.

Migrate personal or system data with minimal effort.

Support for:

SSO (Single Sign-On)

Role-based access control (RBAC)

Multi-company account management

6. Reporting & Analytics

Must include dashboards for:

Productivity scoring

Idle/active ratios

Overtime tracking

Daily/weekly/monthly productivity reports

Export formats:

PDF, XLSX, CSV

Real-time admin alerts for suspicious or low-activity behavior.

7. Privacy, Security & Compliance

All collected data must follow modern compliance standards:

ISO 27001 principles

GDPR-friendly structure

Secure encryption for data in transit and at rest

Codebase must be clean, secure, and professionally structured.

8. Ownership Requirements

Full software ownership must transfer to me.

No recurring licensing fees.

I must have permission to:

Rebrand

Modify

Deploy

Scale

Commercialize (if required)

9. Deliverables

Full, ready-to-use software (all platforms)

Admin dashboard + backend panel

Source code and documentation

Deployment guide

API documentation

White-label rights

Demo login access for evaluation

10. Optional (But Highly Valuable) Features

Please indicate if your existing software includes:

Geo-location or VPN anomaly detection

Screenshot capturing with interval control

Automated time sheets

Project / task-level productivity scoring

Integration with Jira, Asana, Monday.com, or MS Teams

Offline mode logging (syncs when internet is restored)

What to Provide in Your Proposal

Please include:

A demo link or video walkthrough

Technical documentation or feature list

Server architecture overview (high level)

Licensing/ownership details

Pricing for full system transfer

Timeline for handover

Use Budibase and create it . how much time you will need to do this .
this is a simple no code
cutomer log in and enter there data . and in the back end we have to geta report
to aduit the data

System Overview and User Access
Each participating ministry would be provided with secure, role-based login access to the system. User
Roles would be configured to ensure appropriate access control, data integrity, and auditability.
including:
• Ministry / Company Users – authorized users responsible for entering and reviewing ministry-level
data
• Administrative / Audit Users – authorized personnel responsible for data validation, consolidation, and
audit support
Access would be governed by OPS-appropriate security controls, including user authentication, role
based on permissions, and activity logging.




Ministry / Company User ]
│
▼
┌──────────────────────────┐
│ Secure Login (Role-Based)│
│ - Ministry User │
│ - Admin / Auditor │
└───────────┬──────────────┘
│
▼
┌──────────────────────────┐
│ Chart 1: Purchases │
│ (What products/material │
│ were bought) │
│ • Paper │
│ • Plastic │
│ • Oil │
│ • Tires │Ect....
└───────────┬──────────────┘
│
▼
┌──────────────────────────┐
│ Chart 2: Recycling Data │
│ (What was recycled) │
│ • Quantity (kg/MT) │
│ • Processor │
│ • Date │
│ • Method │
└───────────┬──────────────┘
│
▼
┌──────────────────────────┐
│ Chart 3: Residual Waste │
│ (Landfilled / Energy) │
│ • Quantity │
│ • Disposal method │
│ • Facility │
└───────────┬──────────────┘
│
▼
┌──────────────────────────┐
│ Chart 4: Auto Reports │
│ • Monthly summary │
│ • Annual report │
│ • Diversion % │
│ • Audit-ready exports │
└───────────┬──────────────┘
│
▼
┌──────────────────────────┐
│ Customer Portal │
│ • Auto-submission │
│ • Compliance review │
│ • Online audit access │
└──────────────────────────┘

Overview

Extend an existing Go HTTP server that manages FaceTime call links. The server already
handles link creation and call management via REST API. You will add:

1. Browser automation — Join video call links in Chrome/Safari
2. Virtual camera + microphone — OS-level devices for the browser to use
3. New API endpoints — Integrate your work into the existing server
4. Compatibility fixes — Update existing code for latest macOS

---
Existing System (Provided)

A Go/Gin HTTP server running on macOS that exposes:
- POST /link/new — Creates a call link, returns URL
- POST /link/join — Host joins the call
- POST /link/admit — Approves pending join requests
- POST /link/leave — Host disconnects
- GET /status — Server health check

Note: The existing codebase was built for macOS 13. The new Liquid Glass UI in macOS 26
has significant layout changes that will require updating the automation scripts.

---
Environment Required
- Mac (Apple Silicon), macOS 26 with Liquid Glass
- Willing to enable Accessibility / Screen Recording permissions
- Second Apple device or Apple ID to receive test calls

---
Milestone 0 – Fix Existing Functionality for macOS 26

Before adding new features:
1. Test all existing endpoints on macOS 26
2. Identify automation that fails due to Liquid Glass UI changes
3. Update scripts to work reliably with new layouts
4. Document what changed

---
Milestone 1 – Browser Joins Call via Web Link

Add functionality so that when a link is created:
1. The link opens in Chrome (or Safari) on the same Mac
2. Browser fills a provided name (e.g., "Demo") in the join form
3. Browser selects specified camera/microphone devices
4. Browser clicks "Join"
5. Returns success/failure to the calling code

This should integrate with the existing server as a new endpoint like POST /browser/join
or a callable module.

Must handle:
- Waiting for page elements to load
- Browser permission prompts for camera/mic access
- Timeouts and error states

---
Milestone 2 – Virtual Camera + Microphone Relay

Create OS-level virtual AV devices:
1. Virtual Camera ("Demo Virtual Camera") visible to Chrome as a video input
2. Virtual Microphone ("Demo Virtual Mic") visible to Chrome as an audio input
3. Relay process that forwards from a configurable source:
- Video: built-in webcam, test pattern, or video file
- Audio: built-in mic, test tone, or audio file
4. Browser automation from Milestone 1 should select these virtual devices

Implementation options:
- OBS Virtual Camera + BlackHole/Loopback for audio (simpler)
- Custom CoreMediaIO DAL plugin + HAL audio plugin (more control)

---
Milestone 3 – Add Participant + Orchestration Endpoint

Create a single endpoint that runs the full flow:

POST /start-call
{
"target": "+1XXXXXXXXXX",
"name": "Demo"
}

This endpoint should:
1. Create a new call link (existing)
2. Open browser and join via web (Milestone 1)
3. Approve the browser's join request (existing)
4. Add the target phone number/Apple ID to the call
5. Wait for the target to connect
6. Host leaves, browser participant + callee remain connected
7. Return status/logs

---
Deliverables
- Fixes for existing endpoints on macOS 26
- Browser automation module integrated into the Go server
- Virtual device setup (installer scripts or documentation)
- AV relay application with configurable sources
- New /start-call orchestration endpoint
- Updated documentation

---
In Your Proposal, State:
- Confirm you have macOS 26 (Liquid Glass)
- Tools for browser automation (Puppeteer/Playwright/AppleScript, Chrome vs Safari)
- Virtual device approach (OBS-based vs custom plugins)
- How you'll make automation robust (element waits, permission handling)
- Confirmation you have:
- Mac with Apple ID
- Second device/Apple ID for receiving test calls
- Relevant experience with macOS development or browser automation

---

Skills: Golang, Applescript, Automation

Overview

Extend an existing Go HTTP server that manages call links. The server already
handles link creation and call management via REST API. You will add:

1. Browser automation — Join video call links in Chrome/Safari
2. Virtual camera + microphone — OS-level devices for the browser to use
3. New API endpoints — Integrate your work into the existing server
4. Compatibility fixes — Update existing code for latest macOS

---
Existing System (Provided)

A Go/Gin HTTP server running on macOS that exposes:
- POST /link/new — Creates a call link, returns URL
- POST /link/join — Host joins the call
- POST /link/admit — Approves pending join requests
- POST /link/leave — Host disconnects
- GET /status — Server health check

Note: The existing codebase was built for macOS 13. The new Liquid Glass UI in macOS 26
has significant layout changes that will require updating the automation scripts.

---
Environment Required
- Mac (Apple Silicon), macOS 26 with Liquid Glass
- Willing to enable Accessibility / Screen Recording permissions
- Second Apple device or Apple ID to receive test calls

---
Milestone 0 – Fix Existing Functionality for macOS 26

Before adding new features:
1. Test all existing endpoints on macOS 26
2. Identify automation that fails due to Liquid Glass UI changes
3. Update scripts to work reliably with new layouts
4. Document what changed

---
Milestone 1 – Browser Joins Call via Web Link

Add functionality so that when a link is created:
1. The link opens in Chrome (or Safari) on the same Mac
2. Browser fills a provided name (e.g., "Demo") in the join form
3. Browser selects specified camera/microphone devices
4. Browser clicks "Join"
5. Returns success/failure to the calling code

This should integrate with the existing server as a new endpoint like POST /browser/join
or a callable module.

Must handle:
- Waiting for page elements to load
- Browser permission prompts for camera/mic access
- Timeouts and error states

---
Milestone 2 – Virtual Camera + Microphone Relay

Create OS-level virtual AV devices:
1. Virtual Camera ("Demo Virtual Camera") visible to Chrome as a video input
2. Virtual Microphone ("Demo Virtual Mic") visible to Chrome as an audio input
3. Relay process that forwards from a configurable source:
- Video: built-in webcam, test pattern, or video file
- Audio: built-in mic, test tone, or audio file
4. Browser automation from Milestone 1 should select these virtual devices

Implementation options:
- OBS Virtual Camera + BlackHole/Loopback for audio (simpler)
- Custom CoreMediaIO DAL plugin + HAL audio plugin (more control)

---
Milestone 3 – Add Participant + Orchestration Endpoint

Create a single endpoint that runs the full flow:

POST /start-call
"target": "+1XXXXXXXXXX",
"name": "Demo"

This endpoint should:
1. Create a new call link (existing)
2. Open browser and join via web (Milestone 1)
3. Approve the browser's join request (existing)
4. Add the target phone number/Apple ID to the call
5. Wait for the target to connect
6. Host leaves, browser participant + callee remain connected
7. Return status/logs

---
Deliverables
- Fixes for existing endpoints on macOS 26
- Browser automation module integrated into the Go server
- Virtual device setup (installer scripts or documentation)
- AV relay application with configurable sources
- New /start-call orchestration endpoint
- Updated documentation

---
In Your Proposal, State:
- Confirm you have macOS 26 (Liquid Glass)
- Tools for browser automation (Puppeteer/Playwright/AppleScript, Chrome vs Safari)
- Virtual device approach (OBS-based vs custom plugins)
- How you'll make automation robust (element waits, permission handling)
- Confirmation you have:
- Mac with Apple ID
- Second device/Apple ID for receiving test calls
- Relevant experience with macOS development or browser automation

---

• Confirmation you have: - Mac with Apple ID - Second device/Apple ID for receiving test calls
• Confirm you have macOS 26 (Liquid Glass)

We are looking for an experienced Go (Golang) developer to integrate NanoMDM (https://github.com/micromdm/nanomdm) into OpenUEM (https://github.com/open-uem). The integration must be modular, clean, and maintainable, allowing NanoMDM to act as the backend engine while OpenUEM serves as the management interface.

Since NanoMDM does not currently include a GUI, part of this project will involve updating and extending the OpenUEM GUI to expose NanoMDM features such as device information, command workflows, and enrollment status.

This position starts as a 40-hour contract, with the possibility of further work depending on results.

⸻

Primary Objectives
• Build a modular integration layer linking NanoMDM’s backend with OpenUEM
• Add new UI components and update the OpenUEM GUI to support NanoMDM-driven features
• Ensure MDM workflows (enrollment, device communication, commands, queries) flow seamlessly
• Keep the integration isolated and maintainable for future expansion

⸻

Responsibilities
• Analyze existing NanoMDM and OpenUEM architectures
• Implement backend integration for MDM device lifecycle events
• Extend OpenUEM’s GUI for device management, command history, enrollment data, etc.
• Ensure clean separation of concerns between backend modules
• Provide documentation for integration logic and all added UI components
• Work collaboratively with our team, providing regular updates

⸻

Requirements
• Strong, professional experience with Go (Golang)
• Experience with modular/back-end architectures or plugin-style system design
• Familiarity with MDM protocols, NanoMDM, MicroMDM, or OpenUEM is highly preferred
• Frontend/UI experience (React or similar)
• Ability to write clean, well-structured, testable code
• Good communication and willingness to collaborate

⸻

Project Scope
• Approximately 40 hours of development
• Start ASAP
• Milestone-based or weekly progress updates
• Potential extension based on performance and project needs

⸻

Contract Requirements
• NDA (Non-Disclosure Agreement) must be signed
• All code, contributions, and deliverables will be fully owned by us at the end of the contract
• Work must be original and not copied from proprietary sources
• Developer must be comfortable working under an IP assignment agreement

⸻

Deliverables
• A modular NanoMDM integration layer inside OpenUEM
• Updated OpenUEM GUI supporting NanoMDM device management workflows
• Documentation and technical notes
• Code delivered via GitHub repository

Overview
We’re looking for an experienced backend engineer who has previously built high-throughput, real-time request-response systems that process and route data across multiple partners in sub-second latency. The ideal candidate understands how to handle millions of concurrent network calls, manage asynchronous workflows, and implement modular plugin-style logic layers.

This project involves designing, implementing, and deploying a scalable system from scratch that:
1. Accepts external requests from various endpoints.
2. Processes them through configurable logic modules.
3. Selects and returns the most optimal response in real time.

You will work closely with our core engineering team to define architecture, data flow, and deployment infrastructure.

Responsibilities
1. Architect and build a custom event-driven backend capable of handling high QPS (queries per second).
2. Implement configuration-based logic routing using server-side modules.
3. Design APIs for bid/request input, logic processing, and response output.
4. Build a management interface (API-level) for partners and internal configuration.
5. Optimize for concurrency, latency, and scale.
6. Deploy, test, and document the full system for production use.

Required Expertise
1. Strong experience with Node.js, Go, or Python for scalable backend systems.
2. Deep understanding of event-driven architecture, microservices, and low-latency networking.
3. Proficiency with RESTful APIs, WebSocket, and asynchronous request handling.
4. Expertise in Redis / Kafka / NATS / RabbitMQ or similar queue/message systems.
5. Solid knowledge of AWS / GCP / Docker / Kubernetes environments.
6. Understanding of request orchestration, caching, and load balancing.
7. Experience profiling systems for latency and throughput optimization.

Preferred Qualifications
1. Experience building real-time decisioning systems, mediation servers, or configurable backend frameworks.
2. Exposure to auction-like or matching algorithms for real-time response selection.
3. Familiarity with server-to-server integrations, partner endpoint management, and JSON-based logic layers.
4. Prior experience with metrics dashboards, logging pipelines, and alerting for request systems.

Deliverables
1. Complete backend application with configurable request handling and response logic.
2. Integration of partner endpoints and configuration APIs.
3. Deployment and CI/CD setup on cloud infrastructure.
4. Documentation (architecture, endpoints, environment setup).

Notes
Please apply only if you have hands-on experience building real-time backend systems that process large volumes of inbound requests and deliver responses under 200 ms. You’ll be asked to showcase prior work demonstrating your ability to build such a platform end-to-end.

We are seeking a skilled Golang developer to join our team for an innovative project. The ideal candidate will have a strong background in backend development and experience with building scalable applications. You'll be collaborating with our team to design and implement efficient solutions. If you are passionate about coding and have a problem-solving mindset, we would love to hear from you!

Need a Senior Automation Developer (Python, GoLang).
Previous Experience in A2P SMS handling, AIT (Artificial Intelligence Traffic for SMS), IPRN SMS, Traffic Generation.

Need to understand telecom networks infrastructure, with deep experience with network traffic

Build undetectable residential proxy .exe + backend dashboard (C#/Go/Rust only)

Standalone Windows .exe (
100% silent, zero GUI, zero tray icon, hidden window class
Starts HTTP + HTTPS CONNECT + SOCKS5 proxy server on random port every launch
Username/password auth (hardcoded or downloaded from server)
Works without admin rights (user-mode only)
Persistence methods
Random process name + mutex on every start
60-second heartbeat POST to my server containing JSON:[ "ip": "...", "port": 34281, "country": "US", "pcname": "JOHN-DESKTOP", "version": "1.2" ]
dashboard


Only freelancers who have done this thing before.
pls write 'RESIDENTIAL NODE 2025'

Job Title: GCP Engineer (Google Spanner → BigQuery Pipeline + GoLang API Development)

Project Type: Contract (Upwork)
Skills Required: Google Cloud Platform (GCP), Google Spanner, BigQuery, GoLang, Data Pipelines, APIs, Cloud Architecture
Start: Immediate

Project Overview

We are building a data pipeline and API layer for a healthcare transportation platform. We need an experienced GCP engineer who can pull data from Google Spanner, load it into Google BigQuery on a scheduled/streaming basis, and build a GoLang-based API that allows our client to query and retrieve the processed data from BigQuery.

This work is core to our reporting and data-exchange architecture, so we need someone who is highly reliable, experienced with real production workloads, and comfortable working independently with clear deliverables.

⸻

Your Responsibilities

1. Spanner → BigQuery Data Pipeline
• Design and implement a robust pipeline to extract data from Google Cloud Spanner.
• Transform and load that data into Google BigQuery using the most efficient architecture (e.g., Dataflow, Datastream, custom jobs, etc.).
• Ensure incremental updates & high accuracy.
• Optimize for performance, cost, and schema evolution.

2. GoLang API Development
• Build a secure, scalable GoLang API that queries BigQuery and returns results to our client.
• Implement authentication/authorization (service accounts, OAuth, or API keys depending on our configuration).
• Ensure performance best practices for high-volume queries.
• Write clean, well-tested, maintainable Go code.

3. Documentation & Handoff
• Provide clear documentation on:
• Pipeline architecture
• Deployment steps
• API design and endpoints
• Handoff with our internal engineering team.

⸻

Required Experience

You must have hands-on production experience with:
• Google Cloud Spanner (schemas, querying, CDC/change streams, export workflows)
• BigQuery (dataset design, partitioning, optimization, query performance)
• GCP Data Pipeline tools (Datastream, Dataflow, Pub/Sub, Cloud Functions, Scheduler, etc.)
• GoLang (REST API development, concurrency, error handling, unit tests)
• CI/CD deployment on GCP (Cloud Run, GKE, or Cloud Functions)
• IAM, service accounts, and best practices for secure access

⸻

Nice-to-Have
• Experience working with healthcare or HIPAA-compliant systems
• Familiarity with Google Spanner → BigQuery change streams
• Terraform knowledge (optional)
• Logging & monitoring (Stackdriver, Cloud Logging/Monitoring)

⸻

Project Deliverables
1. Working pipeline consistently loading Spanner data into BigQuery
2. GoLang API deployed on GCP (Cloud Run recommended)
3. Authentication and client access set up
4. Documentation + brief walkthrough
5. (Optional) Support for initial integration testing with our client

⸻

What We Provide
• GCP access (Spanner instance, BigQuery datasets, service accounts)
• Existing schema documentation
• Engineering contact for questions
• Clear milestone structure and acceptance criteria

⸻

Who We’re Looking For
• Senior-level engineer
• Someone who can work quickly and independently
• Strong communicator
• Comfortable proposing architecture improvements
• Available for Slack or Upwork messaging during US business hours

⸻

How to Apply

Please include:
1. Examples of real projects involving Spanner, BigQuery, and GoLang
2. Your proposed approach to Spanner → BigQuery ingestion
3. Availability and estimated timeline
4. Hourly rate or fixed-price proposal