Discover Golang Projects on Upwork with Vollna

I need a full-stack team that can architect, design, and launch a web platform that matches or surpasses the experience offered by https://testshift.co.uk/ and https://testhunter.co.uk. The focus is on serving freelance software testers, giving them a smooth way to showcase skills, accept assignments, collaborate with project owners, and get paid quickly and securely.

From account creation to payout, I want every step streamlined and visually polished. Profiles must highlight a tester’s expertise, certifications, and past project ratings. A modern dashboard should surface open test cycles, deadlines, and earnings at a glance, while an in-platform messaging layer keeps conversations tied to each project. Accurate reporting on bug submissions, performance metrics, and payout history is essential so testers can demonstrate value to future clients.

I’m open to the stack you prefer—Golang, Laravel, Django, Node.js, or a SaaS-ready framework—as long as it scales and supports modular feature upgrades. Clean, well-commented code and UI/UX that works equally well on desktop and mobile are non-negotiable.

Deliverables:
• A responsive web application deployed to a live server
• Admin panel for user, project, and payment oversight
• Documentation covering architecture, environment setup, and release process
• Post-launch support for bug fixes during an agreed grace period

To be considered, share one or two live platforms you have built that manage user profiles, real-time collaboration, and integrated payments. I look forward to seeing how you can help me create the go-to place for freelance testers.

Skills: Python, Django, Golang, Node.js, UX / User Experience, UI / User Interface, Web Development, Full Stack Development, Web Application, SaaS Development

Project Overview

I’m looking for an experienced Senior Full-Stack Developer to build an admin dashboard for an existing Web3 decentralized application.

The goal is to develop a reliable, secure, and scalable administrative interface that allows the team to manage application data, monitor activity, oversee platform operations, and interact with blockchain functionality where needed.

You’ll be working with an existing codebase, so the ability to understand the current architecture, identify what needs to be improved, and implement new features without disrupting existing functionality is important.

Responsibilities

- Design and develop the admin dashboard frontend using React and TypeScript.
- Build and maintain backend APIs and services required by the dashboard.
- Integrate the dashboard with existing dApp functionality, smart contracts, and blockchain data.
- Implement secure authentication, session management, and role-based permissions.
- Develop data tables, search, filtering, pagination, forms, and administrative workflows.
- Create dashboard views for platform activity, transactions, user data, and relevant application metrics.
- Integrate REST APIs and connect frontend components with backend services.
- Implement transaction status tracking, error handling, and blockchain data synchronization where required.
- Work with existing database structures and improve data retrieval and management where necessary.
- Ensure responsive layouts, consistent UI components, and a smooth user experience.
- Review the existing codebase, identify technical issues, and recommend practical improvements.
- Write clean, maintainable code and test key features before delivery.
- Document important implementation decisions, API integrations, and setup instructions.

Technical Requirements

- Strong experience with React, TypeScript, JavaScript, and modern frontend architecture.
- Solid backend development experience with Node.js, Express.js, or comparable frameworks.
- Experience designing and integrating REST APIs.
- Strong understanding of database design and data modeling, including PostgreSQL, MongoDB, or similar databases.
- Experience implementing authentication, authorization, and role-based access control.
- Practical experience with Web3 applications, blockchain integrations, and smart contract interactions.
- Familiarity with Ethers.js, Viem, Wagmi, or comparable Web3 libraries.
- Understanding of wallet connectivity, transaction lifecycle management, and on-chain data retrieval.
- Experience handling loading states, failed requests, transaction errors, and asynchronous operations.
- Familiarity with Git, code reviews, testing, and deployment workflows.
- Ability to work independently, troubleshoot technical issues, and take ownership of assigned features.

Dashboard Features

The exact scope will depend on the existing dApp architecture and current requirements, but the dashboard may include:

- Overview dashboard: Key metrics, platform activity, recent events, and operational summaries.
- User management: View user records, search and filter accounts, and manage permitted administrative actions.
- Transaction monitoring: Display transaction history, statuses, timestamps, wallet addresses, and relevant blockchain details.
- Smart contract integration: Read contract data and execute authorized administrative functions where supported by the existing contracts.
- Data management: View and manage application records through connected APIs and database services.
- Activity logs: Track important administrative actions and relevant system events.
- Access control: Separate permissions for administrators and other authorized roles.
- Search and filtering: Provide efficient navigation through large datasets using filters, sorting, and pagination.
- Error and status handling: Clearly display API errors, failed transactions, pending operations, and successful updates.
- Settings and configuration: Provide administrative controls for supported application settings.

These are potential functional areas, not a requirement to implement every feature regardless of the existing product scope.

Security and Code Quality

Security is particularly important because the dashboard may expose sensitive administrative functionality.

The implementation should follow good security practices, including:

- Enforcing permissions on the backend rather than relying only on frontend restrictions.
- Validating and sanitizing user input.
- Protecting sensitive API endpoints and administrative operations.
- Avoiding exposure of private keys, secrets, and privileged credentials.
- Handling wallet signatures and transaction requests safely.
- Recording important privileged actions where appropriate.
- Testing critical workflows and handling unexpected API or blockchain failures.
- Keeping the codebase modular, maintainable, and easy to extend.

Working Approach

I’m looking for a developer who can work with an existing project rather than simply build a standalone dashboard from scratch.

The expected workflow is to review the repository, understand the current frontend and backend structure, identify dependencies and integration points, and then implement the dashboard in manageable stages.

You should be comfortable discussing technical decisions, identifying missing requirements early, and explaining trade-offs when choosing an implementation approach.

I value practical engineering, clear communication, and working features over unnecessary complexity.

Deliverables

- A functional admin dashboard integrated with the existing dApp.
- Completed frontend components and required backend functionality.
- Working API and blockchain integrations within the agreed scope.
- Secure authentication and permission controls where required.
- Tested core administrative workflows.
- Clean, organized, maintainable source code committed to the project repository.
- Setup instructions and brief technical documentation.
- Deployment support and assistance resolving issues discovered during integration.

Ideal Candidate

You’re a senior engineer who has previously delivered full-stack applications, administrative dashboards, or Web3 products in a real development environment.

You can independently navigate an existing codebase, identify the right implementation approach, and deliver complete features across the frontend and backend. You understand that a functional Web3 dashboard requires more than a polished UI: data consistency, transaction handling, permissions, and security matter just as much.

How to Apply

Please include the following in your proposal:

1. Links to relevant admin dashboards, full-stack applications, or Web3 dApps you have built.
2. Your primary frontend and backend technologies.
3. A brief explanation of your experience integrating smart contracts, wallets, and blockchain data.
4. Your approach to working with an existing codebase.
5. Your estimated timeline and availability.

Please focus on relevant projects you have personally contributed to and explain your specific role in their development.

Engagement: Remote, contract-based
Experience level: Senior
Project type: Web3 dApp administration and full-stack development

Looking for an experienced blockchain protocol engineer to work on a blockchain protocol. You will design and implement core protocol logic, work on consensus, networking, and state management, and optimize performance while ensuring correctness under failure conditions. The ideal candidate has strong Rust or Go skills, experience with L1/L2 protocol development, a solid understanding of consensus algorithms and distributed systems, and a rigorous approach to testing.

Experience with Solana, Ethereum, or Cosmos is a plus, as is a background in P2P networking or cryptography.

To apply, share your GitHub or protocol work you have contributed to, and please no generic proposals.

ull-Stack Developer Needed to Build CodeWithGolang — Go Programming Learning Platform

Project Overview

We are building CodeWithGolang, an online learning platform focused on helping developers learn Golang (Go), build practical backend applications, and master production-ready development.

The platform will feature structured learning paths, technical tutorials, coding examples, project-based learning, and premium learning content.

We are looking for an experienced full-stack developer who can turn our existing website designs in Figma into a responsive, high-quality, production-ready web application.

Figma designs: Provided to the selected developer.

Scope of Work

1. Website Development

Develop responsive pages from Figma designs.

Build the homepage, About Us, curriculum, blog listing, blog detail, login, registration, and pricing pages.

Create reusable UI components and a consistent design system.

Ensure responsiveness across desktop, tablet, and mobile devices.

Implement navigation, forms, buttons, search, and other interactive elements.

2. User Authentication and Accounts

Email and password registration and login.

Google sign-in integration.

Forgot password and password reset flows.

Secure session management and logout.

User profile and account management.

Role-based access for administrators and learners.

3. Learning Management System

Structured Golang curriculum with modules and lessons.

Learning paths, lesson pages, and code examples.

Track completed lessons and learner progress.

Mark lessons as completed and resume learning.

Restrict premium content to eligible users.

Provide an architecture that can support quizzes, assignments, and certificates in future phases.

4. Blog and Content Management

Blog listing page with categories and search.

Individual article pages with code syntax highlighting.

SEO-friendly URLs and metadata.

Admin functionality to create, edit, publish, and manage articles.

Support for images, code snippets, and formatted content.

5. Pricing and Payments

Free and premium learning plans.

Pricing page with feature comparisons.

Payment gateway integration, subject to the agreed business requirements.

Order and payment status tracking.

Subscription or one-time purchase support, depending on the final pricing model.

Secure access control for paid content.

6. Backend and APIs

Develop backend services using Golang.

Design clean, versioned REST APIs.

Implement validation, error handling, authentication, and authorization.

Design database schemas and indexes.

Build admin APIs for managing courses, modules, lessons, users, blog posts, and pricing plans.

Provide API documentation using Swagger/OpenAPI.

7. SEO, Performance, and Security

Technical SEO, metadata, canonical URLs, and sitemap.

Optimized page loading and Core Web Vitals.

Secure authentication and input validation.

Rate limiting and appropriate API security controls.

Analytics integration where required.

Basic accessibility and cross-browser testing.

8. Deployment and Documentation

Set up development and production environments.

Configure environment variables and secrets securely.

Dockerize the application.

Provide deployment documentation and setup instructions.

Configure CI/CD where agreed.

Deploy to the selected cloud infrastructure.

Hand over source code, repositories, documentation, and deployment access.

Preferred Technology Stack

Frontend: Next.js, React, TypeScript, Tailwind CSS

Backend: Golang with a suitable web framework

Database: MongoDB or PostgreSQL, based on the final architecture

Authentication: Secure session/JWT approach and Google OAuth

API documentation: Swagger/OpenAPI

Deployment: Docker, with Kubernetes if required by the agreed infrastructure

Version control: Git and GitHub

We are open to recommendations if you can justify a better technical approach.

Required Experience

Strong experience with Golang backend development.

Proven experience building full-stack web applications.

Good knowledge of Next.js, React, and TypeScript.

Experience designing REST APIs and database schemas.

Experience implementing authentication and payment integrations.

Experience building admin panels or learning management systems.

Familiarity with Docker, CI/CD, cloud deployment, and production debugging.

Ability to write maintainable code and clear technical documentation.

Experience with online education platforms, developer tools, or content-heavy websites is a plus.

Deliverables

Fully functional website matching the approved Figma designs.

Responsive frontend and backend services.

Authentication and account management.

Curriculum and lesson management functionality.

Blog and content management functionality.

Pricing and agreed payment functionality.

Admin dashboard and APIs.

Database schemas and API documentation.

Tested deployment and setup documentation.

Complete source code and project handover.

Workload: full-time, remote
Start: asap
Duration: long-term (6-12 months anticipated, final term TBD)
Working Hours: 8 hours/day | Core availability 10:00-17:00 UK time, with flexibility for overlap with Eastern Canada
Hardware: Candidate may use their own laptop; VPN required for production changes or production-data investigation

ROLE OVERVIEW
A digital asset infrastructure organization requires a Senior Go Engineer. The platform uses cryptographic security and multi-party computation (MPC) to protect and sign digital-asset transactions. The primary focus of this role is to take primary ownership of the Go-based Virtual Signer and assist in maintaining shared signing SDKs and integrations across server and mobile platforms.

The Virtual Signer participates in MPC and threshold signing alongside mobile devices. This is an opportunity to take ownership of a security-critical component, strengthen its production reliability, and contribute to future transaction approval and post-quantum signature capabilities.

ABOUT THE ENVIRONMENT
• The Go-based Virtual Signer orchestrates signing between server and mobile participants. It integrates with MPC and threshold-signature libraries, supports encrypted storage, and must recover safely from interrupted signing sessions and other failures.
• The component has been rebuilt over roughly the past year and is currently at the MVP stage. It is functional, with outstanding pull requests, logging/visibility improvements, and race conditions to address. The incoming engineer may have limited handover from the previous maintainer.
• The engineer will work with backend and mobile engineers, testing support, and a cryptographer who also maintains the repository. Collaboration across UK and Eastern Canada working hours will be important.
• The environment includes Go, Linux, and Docker, with shared SDKs and bindings for Swift, Kotlin, and JavaScript/TypeScript. Standard collaboration tooling (Jira, Slack, GitHub, Google Workspace) is used.

The initial focus is establishing a robust production baseline: understand the codebase, resolve reliability and security issues, improve tests, and support releases. Later work may include transaction approval functionality and post-quantum signing in collaboration with cryptography specialists.

RESPONSIBILITIES
Virtual Signer Engineering
• Maintain and improve the Go Virtual Signer, including signing orchestration, communication between participants, encrypted storage, and recovery from failures.
• Investigate concurrency, timeouts, interrupted sessions, network failures, and service restarts; review outstanding pull requests and address race conditions.
• Improve logging and visibility, assess the existing implementation critically, and make careful, maintainable changes.
• Support agreed transaction approval features and future post-quantum signature work.
Cryptography, SDKs & Cross-Platform Integration
• Maintain integrations with MPC and threshold-signature libraries, working with cryptography specialists where changes affect protocol security.
• Contribute to shared SDKs and bindings connecting Go with Swift, Kotlin, and JavaScript/TypeScript.
• Work with backend and mobile engineers to preserve API compatibility and consistent signing behavior across releases.

Quality, Testing & Operations
• Improve automated tests for signing correctness, failure recovery, and interoperability between virtual and mobile signers.
• Support Linux and Docker deployments, dependency upgrades, monitoring, release processes, and operational documentation.
• Investigate production issues and occasionally assist with setup or logging problems.

Ownership & Technical Judgment
• Take primary ownership of a security-critical codebase with limited handover and independently establish a robust production baseline.
• Assess technical risks and trade-offs, explain decisions clearly, and make incremental changes with sound security judgment.
• Collaborate pragmatically with backend, mobile, testing, and cryptography specialists across time zones.

REQUIREMENTS
Essential Technical Experience
• Strong hands-on production Go, including goroutines, channels, context cancellation, race detection, profiling, and resource management.
• Experience owning production services, diagnosing complex failures, and delivering well-tested fixes.
• Distributed-systems knowledge, including asynchronous messaging, retries, idempotency, state management, and partial failures.
• Practical security engineering: authentication, encrypted storage, sensitive-data handling, and safe logging.
• Applied cryptography concepts, including digital signatures, hashing, key management, and signature verification.
• Automated testing, CI/CD, Linux, containers, and production observability.
• Ability to understand an established codebase, make careful incremental changes, and explain technical decisions clearly.

Strongly Preferred / Desirable Technical Experience
• JavaScript/TypeScript SDKs and mobile bindings, including asynchronous APIs, packaging, compatibility, and Go/mobile interoperation.
• React Native/Expo, Swift, or Kotlin; experience with mobile lifecycle, secure storage, or native modules.
• MPC or threshold signatures, distributed key generation, and changes to signing participants.
Blockchain transaction signing, including signing payloads and chain-specific requirements.
• Confidential computing and hardware attestation, particularly AMD SEV-SNP, are especially valuable among the desirable skills.
• MQTT, Protocol Buffers, Prometheus, or Open Telemetry; familiarity with post-quantum signature schemes is also desirable for the longer-term roadmap.

Market Experience
• Experience with digital asset infrastructure, blockchain signing, or MPC is valuable, but the priority is strong production Go and sound security judgment.
• Relevant experience in other security-critical distributed systems can also demonstrate fit.
• Candidates do not need experience with every desirable technology; evidence of ownership, careful delivery, and learning across platform boundaries matters.

Soft Skills & Working Style
• Independent and able to understand an existing repository with limited handover.
• Strong security judgment, attention to correctness, and a careful approach to critical signing systems.
• Able to assess implementation choices critically and explain risks and trade-offs clearly.
Pragmatic and collaborative when working with backend, mobile, and cryptography specialists.
• Comfortable diagnosing production failures and improving reliability through tested changes.
• Effective remote communication and flexibility for collaboration across UK and Eastern Canada working hours.
• Able to take ownership without relying on detailed instructions or extensive handover.
Willing to investigate occasional customer setup or logging issues.

⚠️ Important:
Candidates who attach a CV to their application will be prioritized.

Lead Development team to Design, develop, and maintain full-stack applications using Golang (backend) and SvelteKit (frontend).
• Build, optimize, and maintain GraphQL APIs for data-driven applications.
• Implement microservices for modular, scalable, and resilient systems.
• Familiar with PostgreSQL databases, including schema design and query tuning.
• Collaborate cross-functionally with product, design, and operations teams to deliver high-quality software.
• Ensure code quality through peer reviews, testing, and CI/CD practices.
• Contribute to system architecture discussions and drive engineering best practices.
• Support performance tuning of application systems.
Required Qualifications
• Bachelor’s degree in Computer Science, Software Engineering, or a related field.
• 7+ years of professional experience as a full stack or backend engineer.
• Strong proficiency in Golang for backend development.
• Proficient in SvelteKit or similar modern frontend frameworks (React, Vue, etc.).
• Experience building and maintaining GraphQL APIs.
• Deep understanding of microservices architecture and distributed systems.
• Strong SQL skills with experience in MS SQL and PostgreSQL.
• Familiarity with CI/CD pipelines, testing, and version control systems.
• Excellent problem-solving, debugging, and communication skills.
Good to Have
• AWS project experience (e.g., Lambda, ECS, RDS, S3, API Gateway).
• Familiarity with Temporal Workflow or similar orchestration frameworks.
• Experience with Node.js for backend or API development.
• Experience with containerization/orchestration (Docker, Kubernetes).
• Background in performance tuning, observability, and system optimization.
• Experience mentoring or leading small engineering teams.

We’re building an RWA marketplace focused on tokenizing and trading real-world assets. We’re looking for a Full Stack Blockchain Engineer to help develop smart contracts, wallet integration, asset tokenization, and marketplace features.

We value clean code, strong problem-solving skills, and practical Web3 experience.

micro1 is selecting Cyber Security Engineers to contribute technical expertise to a dynamic customer project. In this role, you'll apply your expertise to help train next-generation AI systems. Your work will shape how models learn, reason, and perform through high-quality, real-world input. No prior experience in AI is required — your domain knowledge is what matters.



What we're looking for:

Analyze, debug, and resolve software bugs and vulnerabilities across diverse codebases.
Implement new features and enhance existing functionality in projects using Python3, Java, Rust, Go, C++, or TypeScript.
Refactor legacy code to improve maintainability, security, and performance.
Perform codebase audits, penetration testing, and other security assessments to identify and mitigate risks.
Contribute to backend development and optimize application performance for scalability and security.
Document findings, suggest improvements, and provide real-world insights to improve AI training datasets.


Preferred Qualifications:

Expertise in one or more languages: Python3, Java, Rust, Go, C++, or TypeScript.
Proven experience in debugging, bug fixing, and backend development for complex systems.
Strong background in cybersecurity practices, including pentesting, security audit, and vulnerability assessment.
Proficiency in algorithms, codebase refactoring, and optimizing software for performance and security.
Ability to communicate complex technical findings clearly and concisely.
Familiarity with secure software development lifecycles and modern threat landscapes.
Experience contributing to AI-related or data-driven projects is a plus, but not required.


Process:

Apply to the role, filling out the screening questions
Complete AI Interview (approx. 30 minutes)
Technical Assessment (Tentative)
Hiring Manager review


Compensation Structure

Compensation is output-based; experts are paid per task that meets the project specifications. The time required to complete work may vary depending on the expert’s experience and workflow. Minimum submission requirements apply. Experts must submit a minimum of tasks per week.



Start Timeline & Availability

We typically fill roles within 48 hours and are looking for experts ready to jump in right away. If selected, we expect you to start your first tasks within 24–48 hours of completing onboarding.

Schedule: Flexible, you pick the hours and days (including weekends if desired)

Job Type: Contractor (~15 hrs a week)

I'm looking for an experienced Golang (Go) engineer to work on a backend/systems-level project involving an existing Go codebase.

Budget: $3000 fixed price
Language: Go 1.20+
Environment: Linux / Git

## Project

The project involves extending and improving an existing Go application according to a detailed technical specification.

The work will involve understanding the existing architecture, implementing new functionality, and ensuring that the changes integrate cleanly with the current codebase.

The project is intended for an engineer who is comfortable building reliable backend/system software and cares about performance, correctness, maintainability, and clean design.

## Requirements

Strong practical experience with:

* Go / Golang
* Goroutines and concurrency
* Channels and synchronization
* Go standard library
* HTTP/REST APIs where applicable
* Testing with Go
* Debugging and troubleshooting
* Writing production-quality code

Experience with high-performance backend systems, distributed systems, networking, databases, messaging systems, cloud infrastructure, or other performance-sensitive software is a plus.

## What I Expect

The developer should be able to:

* Understand an existing Go codebase quickly
* Follow an existing architecture and coding style
* Implement functionality without unnecessary rewrites
* Design safe and efficient concurrent code
* Identify and handle edge cases
* Write maintainable and testable code
* Investigate performance or reliability issues
* Communicate clearly about technical issues and progress

## Proposal

Please include:

1. Years of practical Go experience.
2. Go versions you regularly use.
3. One or two examples of technically challenging Go projects you have completed.
4. Your experience with concurrency and performance optimization.
5. Your experience working with existing Go codebases.
6. Your availability and estimated completion time.

I will provide the detailed project specification and relevant codebase to the selected developer.

Project Overview

We are building Quay, a crypto and card platform designed to connect blockchain-based assets with a secure payment card experience.

We have an existing React/TypeScript Web3 application and are looking for an experienced full-stack engineer to assess the current codebase, complete the existing frontend, build the required backend services, integrate third-party providers, and prepare the platform for production.

This is an existing project, not a greenfield application. You will be expected to understand the current architecture, identify what is already working, and build on top of it wherever practical.

We are looking for an engineer who can take ownership of the technical implementation and deliver a tested, secure, and functional product.

Current Technology Stack

Existing frontend:

React 18 and TypeScript

Tailwind CSS and styled-components

Ethereum and Web3 wallet connectivity

ethers.js and Web3Modal

Uniswap V3 swap and liquidity integrations

Token vesting functionality

Transak integration for purchasing crypto

Existing dashboard, wallet, and token management interfaces

Backend and infrastructure to be developed:

Go (Golang) backend API

PostgreSQL database

Secure authentication and authorization

Double-entry financial ledger

Card issuer or Banking-as-a-Service (BaaS) integration

KYC/identity verification integration

Blockchain deposit monitoring and reconciliation

Secure webhooks and transaction processing

You should be comfortable working across the frontend, backend, database, blockchain integrations, and deployment infrastructure.

Scope of Work

1. Audit and Complete the Existing Application

Review the existing repository and understand its architecture.

Set up the project locally and verify that it builds and runs.

Identify incomplete functionality, bugs, outdated dependencies, and integration issues.

Test wallet connectivity, dashboard data, token swapping, liquidity features, and vesting functionality.

Fix existing issues and improve reliability and maintainability.

Verify configuration, network settings, and environment variables.

Document any necessary Ethereum network or dependency upgrades.

2. Build the Backend API

Design and implement the Quay backend using Go.

Implement secure user authentication and authorization.

Design REST API endpoints for card-related operations, account balances, transactions, and user status.

Integrate PostgreSQL with appropriate database migrations and transaction handling.

Implement robust input validation, error handling, logging, and API documentation.

Keep private credentials and sensitive integrations on the server, never in the frontend.

3. Implement the Financial Ledger

Build a reliable double-entry ledger to track customer balances and financial transactions.

Maintain accurate, auditable records of credits, debits, fees, holds, reversals, and adjustments as applicable.

Prevent duplicate processing of requests and webhook events.

Implement transaction idempotency, concurrency controls, and reconciliation.

Ensure card authorization decisions use authoritative available-balance information.

Ensure a transaction cannot be approved when the available balance is insufficient.

Financial correctness is a critical requirement for this project. We do not want a system that relies solely on frontend balances or blockchain token balances to determine whether a card payment should be approved.

4. Integrate Card Issuing and KYC Providers

Evaluate and integrate the agreed card issuer or BaaS provider.

Implement sandbox card issuance and the required user onboarding workflow.

Integrate a KYC/identity verification provider.

Track verification and card lifecycle statuses.

Support virtual card status, transaction history, and card freeze/unfreeze functionality where supported by the provider.

Process issuer authorization requests and webhooks reliably.

Ensure declined, approved, reversed, and failed transactions are handled correctly.

Use the issuer's secure card-display mechanism for sensitive card details. Do not store raw card numbers or CVVs in the Quay database.

Provider selection and API access will be coordinated as part of the project.

5. Implement Deposit Processing

Design a secure process for detecting supported blockchain deposits.

Verify the destination, token, amount, network, and required confirmation count.

Credit the internal ledger only after the configured deposit-verification requirements are satisfied.

Prevent duplicate credits and handle reorganizations, failed transactions, and reconciliation exceptions.

Implement clear deposit statuses and transaction history.

Establish the relationship between wallet ownership, deposits, internal balances, and card spending.

The blockchain deposit flow and financial ledger must be designed as separate but properly reconciled components.

6. Connect the Frontend to the Backend

Integrate the existing React application with the new backend API.

Add the necessary card-related screens and account states.

Implement onboarding, KYC status, card status, balance information, transaction history, and card controls.

Add loading, empty, success, and error states.

Ensure the interface behaves correctly on desktop and mobile.

Preserve existing working functionality wherever possible.

7. Testing, Security, and Deployment

Write unit and integration tests for critical backend and frontend functionality.

Test ledger accuracy, insufficient-balance declines, duplicate webhooks, failed transactions, and reconciliation.

Test the card issuer and KYC integrations in their sandbox environments.

Review authentication, authorization, secrets management, input validation, and sensitive-data handling.

Set up the agreed staging environment and deployment process.

Provide deployment documentation, environment configuration guidance, API documentation, and handover instructions.

Production launch is subject to successful testing, provider approvals, and any applicable compliance requirements.

First Milestone: Working Sandbox Card Flow

The first milestone should establish a functioning end-to-end flow in a sandbox environment:

A user completes the agreed onboarding and verification process.

The user has an eligible, verified funding balance.

The backend records the balance accurately in the ledger.

A sandbox virtual card can be issued through the selected provider.

A supported card transaction is approved when sufficient available funds exist.

A transaction is declined when available funds are insufficient.

Transactions and provider webhooks are recorded correctly without duplicate processing.

The card can be frozen and unfrozen where supported by the provider.

The frontend displays the correct card status, balance, and transaction information.

We will agree on the detailed acceptance criteria and provider capabilities before implementation begins.

Required Qualifications

Please apply only if you have relevant hands-on experience with most of the following:

Strong full-stack development experience with React and TypeScript.

Professional backend development experience with Go/Golang.

PostgreSQL schema design, migrations, and transactional systems.

Experience building financial applications, payment systems, fintech platforms, or money-movement APIs.

Experience implementing double-entry ledgers, balance reconciliation, and idempotent transaction processing.

Experience integrating third-party APIs, webhooks, and external service providers.

Understanding of authentication, authorization, application security, and sensitive-data protection.

Experience with Ethereum, EVM networks, wallet connectivity, and blockchain transaction monitoring.

Automated testing, CI/CD, deployment, and production troubleshooting.

Particularly valuable: Experience with card issuing, Banking-as-a-Service providers, payment authorization, KYC providers, and systems that make real-time spending decisions based on available balances.

We value demonstrated delivery experience over general claims of expertise.

Deliverables

Audited and documented existing codebase.

Completed and tested existing frontend functionality.

Working Go backend API.

PostgreSQL schema and migrations.

Financial ledger and reconciliation functionality.

Sandbox card issuing and KYC integration.

Verified deposit-processing workflow.

Integrated frontend card and account interfaces.

Automated tests and security documentation.

Staging deployment and setup instructions.

Complete source code, configuration templates, and technical handover documentation.

How We Will Work

Start with a technical review of the existing codebase.

Submit a proposed architecture and prioritized implementation plan.

Break the work into clearly defined milestones.

Provide regular progress updates and demonstrate working functionality.

Use version control and submit reviewable code changes.

Document technical decisions and known limitations.

Deliver source code and documentation through the agreed repository.

We prefer a developer who communicates clearly, raises risks early, and can explain technical decisions in practical terms.

Application Instructions

To be considered, please answer the following questions in your proposal:

Relevant experience: Describe a fintech, payment, card-issuing, or money-movement system you personally helped build. What was your specific contribution?

Technical architecture: How would you structure the Go backend, PostgreSQL ledger, blockchain deposit processor, and card issuer integration for this project?

Insufficient-balance authorization: How would you guarantee that concurrent card transactions cannot spend more than the user's available balance?

Existing codebase: How would you approach taking over and completing an existing React/TypeScript Web3 application rather than rebuilding it from scratch?

First milestone: What would you deliver in the first milestone, what dependencies would you need from us, and how would you demonstrate that it works?

Availability and estimate: What is your availability, estimated timeline, and preferred engagement structure?

Please include links to relevant work, a GitHub profile where appropriate, or a concise technical case study. Do not share confidential information belonging to previous clients.

Generic proposals without answers to the technical questions above may not be considered.

We are looking for a technically strong, security-conscious engineer who can take ownership of the implementation and help bring Quay to a reliable, production-ready state.

We are looking for an experienced Golang Engineer to join our development team and help build, maintain, and improve backend services and APIs.

You will work closely with other engineers to design reliable, scalable, and maintainable systems. We are looking for someone with strong problem-solving skills, clean coding practices, and a proactive approach to development.

Responsibilities

* Design, develop, and maintain backend services using Go (Golang).
* Build and integrate REST APIs and backend systems.
* Work with databases such as PostgreSQL, MySQL, or Redis.
* Implement concurrent processing using goroutines and channels.
* Troubleshoot bugs, improve performance, and optimize existing services.
* Collaborate with team members through code reviews, technical discussions, and regular progress updates.

Requirements

* Solid experience with Go (Golang) and backend development.
* Experience designing and implementing REST APIs.
* Good understanding of concurrency, goroutines, channels, and context cancellation.
* Experience with SQL databases and database optimization.
* Familiarity with Git, Docker, and automated testing.
* Understanding of software architecture, error handling, and security best practices.
* Ability to communicate clearly and work independently in a remote team.

Project Details

* Position:** Golang Engineer
* Engagement:** Contract / Freelance
* Work arrangement:** Remote
* Duration:** Long-term opportunity for the right candidate
* Start:** As soon as the right candidate is selected

### How to Apply

Please include the following in your proposal:

1. A brief introduction and summary of your Go development experience.
2. Links to relevant GitHub repositories or previous projects, if available.
3. A brief assessment
4. Your hourly rate and weekly availability.
5. Your earliest possible start date.

We look forward to working with a developer who values code quality, reliability, and collaboration.

Overview

We are looking for an experienced Scala Engineer to join our team and contribute to the development and maintenance of backend services and scalable applications.

The ideal candidate has strong Scala programming skills, understands functional programming principles, and can write clean, reliable, and maintainable code. You should be comfortable collaborating with other engineers in a remote environment.

Responsibilities

* Develop, maintain, and optimize backend services using Scala.
* Design and implement reliable, scalable, and maintainable software.
* Work with REST APIs, databases, and third-party integrations.
* Write unit tests and integration tests to ensure code quality.
* Review code, troubleshoot issues, and improve application performance.
* Collaborate with the team on technical design, implementation, and code reviews.
* Document technical decisions and development processes.

Requirements

* Solid experience with Scala and the JVM ecosystem.
* Knowledge of REST APIs, SQL databases, and backend architecture.
* Experience with Git, automated testing, and modern development workflows.
* Strong problem-solving and communication skills.

Engagement Details

* Position:** Scala Engineer
* Work arrangement:** Remote
* Employment type:** Contract / Freelance
* Duration:** Long-term opportunity for the right candidate
* Start date:** As soon as available
* Seniority:** Intermediate to Senior

How to Apply

Please include the following in your proposal:

1. A brief introduction and summary of your Scala experience.
2. Examples of relevant projects you have worked on.
3. Your GitHub profile or other relevant technical portfolio, if available.
4. A brief assessment

We look forward to working with a skilled Scala engineer who is interested in contributing to a collaborative engineering team and building reliable software.

We are seeking an experienced Platform Engineer or Software Development Lifecycle (SDLC) Tooling Engineer for a hands-on development and integration project involving Conduit, our proleptic event orchestration engine.

We are not looking for someone who simply uses CI/CD tools. We need an engineer who has built, extended, or contributed to the development of platform engineering or SDLC tooling. Experience contributing to open-source projects such as Jenkins, Spinnaker, Tekton, Argo, FluxCD, or comparable systems is highly desirable.

### About the Technology
Conduit is a tool-agnostic, proleptic event orchestrator designed to close the operational feedback loop across an organization's SDLC ecosystem.

Traditional monitoring tells you when something has gone wrong. Conduit takes a different approach.

By correlating events and internal tool state against declared workflow expectations, Conduit observes the entire SDLC ecosystem as work progresses. It identifies unexpected behavior, evaluates its impact across the workflow, and enables corrective actions anywhere along the execution chain—even while other systems remain in flight.

This isn't alerting. It's actionable orchestration based on the real-time impact of unexpected behavior.

Conduit uses Koine and the KoineDSL, a domain-specific language (DSL) for expressing workflow intent, and an extensible plugin architecture for interacting with the underlying tools.

Iron Monkey is our companion SDLC event simulator, designed to exercise workflows under expected and unexpected conditions.

The primary implementation language is Go (Golang).

### Scope of Work
The selected engineer will receive access to the necessary source code, libraries, and project documentation.

The engagement includes:
1. Local Environment Setup
- Build, configure, and successfully run Conduit locally.
- Build, configure, and successfully run Iron Monkey locally.
- Demonstrate a working local environment.
2. Koine DSL Development
- Create or extend custom Koine expressions to describe an SDLC workflow.
- Configure Conduit to observe and evaluate the declared workflow expectations.
- Validate the workflow using Iron Monkey.
3. Plugin Integration and Development
- Use the existing Conduit plugin library to integrate the necessary SDLC tool capabilities.
- Extend or implement plugins where necessary to close the operational feedback loop.
- Demonstrate how internal tool state and external workflow events are correlated to detect unexpected behavior and support corrective action.
4. End-to-End Demonstration
- Execute the workflow using Conduit and Iron Monkey.
- Demonstrate expected execution and at least one unexpected condition.
- Show how Conduit detects the deviation and initiates the appropriate action through its plugin architecture.

### Deliverables and Acceptance Criteria
This is a working-code engagement, not a research, consulting, or architectural assessment project.

The expected deliverables are:
- A working local Conduit and Iron Monkey implementation.
- Functional Koine DSL additions or extensions.
- Any necessary plugin additions or modifications.
- A live demonstration of the complete workflow.
- A clean Git diff containing all source code changes.
- Documentation sufficient to reproduce the demonstration.

Final acceptance requires that I can reproduce the demonstrated functionality in my own local environment using the delivered changes.

A successful demonstration on the contractor's machine alone does not constitute project completion.

### Required Qualifications
- Strong Go development experience.
- Direct experience building, maintaining, or contributing code to SDLC or platform engineering tools.
- Experience with CI/CD orchestration, workflow engines, or event-driven systems.
- Experience developing integrations, plugins, or extensions for existing software platforms.
- Strong understanding of software lifecycle automation and distributed systems.
- Ability to work independently with unfamiliar codebases and APIs.
- Experience using Git and delivering clean, reviewable changes.
Important: Experience configuring Jenkins pipelines, managing Kubernetes deployments, or using CI/CD services is not sufficient on its own. We are specifically seeking engineers who understand how these systems are built and extended.

### Preferred Experience
- Contributions to open-source CI/CD or platform engineering projects.
- Familiarity with CDEvents and CloudEvents.
- Experience with event-driven orchestration or workflow engines.
- Experience building DSLs, parsers, or declarative workflow systems.
- Experience with observability, event correlation, or automated remediation.
- Experience building developer platforms or internal developer platforms (IDPs).

### How to Apply
Please include the following in your proposal:
1. Tooling Development Experience: Identify an SDLC or platform engineering tool you have built, extended, or contributed to. Describe your actual code contributions rather than how you used the tool.
2. Code Examples: Provide GitHub links, pull requests, or other evidence of relevant engineering work.
3. Go Experience: Describe a Go project involving plugins, event processing, workflow orchestration, or comparable systems.
4. Approach: Briefly describe how you would approach learning an unfamiliar orchestration engine, extending its DSL, and verifying the behavior through simulation.

Generic proposals listing CI/CD technologies without demonstrating actual tooling development experience will not be considered.

### Future Opportunities
This engagement is an opportunity to work directly with an emerging open-source orchestration platform.

Successful completion may lead to additional development engagements involving Conduit, Koine, and other Sol Duara projects.

We are looking for an engineer who enjoys understanding how systems work, extending their capabilities, and solving problems at the infrastructure level.

We're an early-stage company based in Islamabad, currently in stealth, so we can't share details about the company yet. We're hiring a full-time Backend Engineer to own core parts of our backend.

WHAT YOU'LL WORK ON
- Designing and building a multi-tenant access model on Kubernetes: RBAC, namespace isolation, and resource quotas
- Building gRPC services and REST APIs
- Real-time event streaming to a web frontend
- Building and operating a Kubernetes operator for a container registry
- Backend integration for AI-powered features
- Hardening services under production-level load

WHAT WE'RE LOOKING FOR
- 3+ years building production backend services with Go as your primary language
- Experience designing gRPC/protobuf APIs, including evolving an API without breaking existing clients
- At least one production Kubernetes setup shared by multiple teams, with namespace isolation and resource quotas
- Hands-on container registry experience (Harbor, ECR/GCR/ACR or similar)
- Comfort reading and extending Kubernetes operator code (controller-runtime, CRDs)
- Comfortable joining an on-call rotation

NICE TO HAVE
- LLM API integration experience
- WebSocket or SSE experience

ENGAGEMENT
- Full-time

HOW TO APPLY
Please share your latest CV and mention your years of production Go experience.

Expert Full-Stack Engineer (Go/Golang + Next.js) – Headless API Proxy Wrapper for GoHighLevel

**Job Description:**
We are seeking an expert, enterprise-grade Full-Stack Developer (or small dev team) to build a proprietary, high-speed headless frontend presentation layer that entirely masks our GoHighLevel (GHL) backend instance.

Our application scales to a target of 15,000 sub-accounts. Our clients rely heavily on live texting, click-to-dial functionality, and pipeline updates. System speed, absolute uptime stability, and data security are strict business-critical mandates. If the interface drops, we lose clients.

The core infrastructure uses GHL strictly as a backend database engine (System of Record) for contact management, workflows, automation triggers, and Twilio SaaS re-selling. We are entirely bypassing GHL's native frontend UI.

**Required Architecture & Developer Stack:**

• Backend: Go (Golang). Must act as a stateless API Proxy and Caching Buffer Gateway utilizing native goroutines for high concurrency webhook routing.

• Frontend: Next.js (React) + Tailwind CSS + Shadcn UI (or similar component library). Must compile as a highly responsive Progressive Web App (PWA) optimized for desktop and mobile browsers.

• Caching & Real-Time Sync: Redis (Managed). Used to temporarily buffer active conversation loops and avoid GHL API v2 rate blocks.

• Stream Delivery: Persistent WebSockets or Server-Sent Events (SSE) to catch incoming GHL webhooks and dynamically render text/call events on the agent's screen in under 30ms.

**Strict Technical Constraints & Deliverables:**

1. API Rate Limit & Token Management: You must construct an automated background task loop in Go to manage multi-tenant OAuth2 authorization and cycle security tokens silently before their 24-hour expiration lifecycles.

2. Bandwidth Optimization (Delta-Sync): Sub-accounts average 20–40 custom fields per contact record. The platform must never pull or push raw, heavy CRM schemas blindly. You will implement JSON Patches (RFC 6902) to sync data adjustments over WebSockets.

3. List Virtualization: The Next.js frontend must utilize windowed rendering loops (e.g., TanStack Virtual / react-window) for pipeline lanes and communication threads to eliminate DOM bloating.

4. Telephony Integration: Outbound click-to-dial will be executed through GHL's native Two-Legged Bridge Call API endpoints, routing efficiently back to our custom workspace layout wrapper.

5. Session Isolation: Absolute cryptographic multi-tenant session isolation in memory to completely prevent any data bleeding across active sub-accounts.

Location: Remote, European Union (EU)
Engagement: Initial 3-month trial, with the intention to continue long-term
Start Date: As soon as a suitable candidate is available

We are looking for a Senior Backend Engineer (Golang) to join a product team at an insurtech client building digital and embedded insurance solutions for e-commerce and financial platforms.

This role is ideal for a hands-on senior engineer who can design and develop scalable backend services, take ownership of system architecture, mentor other engineers, and ensure the reliability and performance of production systems.

Key Responsibilities

Design, develop, and maintain scalable gRPC and REST APIs for core insurance services.

Own complex backend services throughout the development lifecycle, from requirements and architecture to deployment and production support.

Contribute to microservices architecture, system design, technology selection, and engineering best practices.

Build reliable, high-performance services using Golang and cloud-native technologies.

Mentor junior and mid-level engineers through code reviews, design reviews, and pair programming.

Improve automated testing, observability, CI/CD pipelines, and operational readiness.

Troubleshoot production issues, lead root-cause analysis, and implement long-term reliability improvements.

Optimize system performance, scalability, and infrastructure costs.

Apply appropriate security practices and account for financial and insurance industry compliance requirements.

Use AI development tools responsibly, validating generated code for correctness, security, and maintainability.

Required Qualifications

8+ years of backend development experience, including 5+ years of hands-on production experience with Golang.

Strong experience designing and maintaining production-grade gRPC and REST APIs.

Proven ownership of complex backend services and architectural decisions.

Deep understanding of distributed systems, microservices, and event-driven architecture.

Hands-on experience with Docker, Kubernetes, and modern DevOps practices.

Strong PostgreSQL skills, including data modeling, query optimization, and performance tuning.

Experience with messaging systems such as Kafka or RabbitMQ.

Experience troubleshooting production systems and improving reliability.

Demonstrated ability to mentor engineers and promote clean coding practices.

Regular and responsible use of AI development tools, including prompt engineering and critical validation of AI-generated code.

Excellent English communication skills and the ability to explain technical decisions clearly.

Preferred Qualifications

Experience in insurance, insurtech, fintech, financial services, or other regulated industries.

Experience building digital or embedded insurance products.

Experience operating large-scale, cloud-native backend systems in production.

Core Technology Stack

Golang, gRPC, REST APIs, Microservices, Distributed Systems, Event-Driven Architecture, Docker, Kubernetes, PostgreSQL, Kafka, RabbitMQ, CI/CD, Cloud-Native Technologies, Observability, DevOps, and AI Development Tools.

# About Embold

Embold runs Creator Programs for Canadian brands. Our platform powers every program, and our network of 12,000+ vetted Canadian creators delivers the content. Our team handles strategy, negotiations, shipping, and payments. Clients keep final approval.

You would work on that platform: the web application our team uses to run programs, track real-time metrics, review content, and pay creators.

# The role

You will build and maintain features across our React frontend and Django backend. You will ship work end to end, from ticket to production, and help keep the codebase clean as it grows.

You will report to a senior engineer who will mentor you. Expect regular code reviews, pairing, and direct feedback on your technical growth.

# What you will do

- Build features across the React frontend and Django backend
- Fix bugs and work down the backlog with clear, written updates
- Contribute to services around the core app, including background jobs and image processing
- Learn from your senior engineer through code reviews and pairing
- Use AI tools in your daily work and tell us what works and what doesn't

# Requirements

- 3 to 5 years of software engineering experience, including 2+ years as a full-stack engineer
- 3+ years of React
- 2+ years of Django
- 1+ year of Docker
- 1+ year of prompt engineering

# Nice to have

- Golang experience
- Familiarity with AWS
- Experience building microservices

# What we would like to see

- At least one major project you completed without any AI assistance
- Public GitHub repos with your projects
- Samples of how you use AI in your work (prompts, workflows, or a short write-up)

We are looking for a developer to support a project involving backend and mobile development. The work includes building and maintaining application components, troubleshooting issues, and helping improve overall performance. You should be comfortable working on both backend and mobile parts of the project and able to collaborate effectively with the team. Experience with similar development tasks is important for success in this role.

Job Title: Senior Go/Golang Developer
Job type: Full-time
Location: Remote

About the Project
We are a fast-growing international education and relocation consultancy. To support our global expansion, we are building a proprietary, custom web-based internal operations portal from the ground up. This system will be the backbone of our business, handling everything from student/client records and secure document management to staff role permissions, complex visa/application workflows, and task tracking.
We are looking for a highly skilled Senior Go (Golang) Developer to architect and build the robust backend services that will power this portal.

Key Responsibilities
Custom Portal Architecture: Architect, build, and maintain a highly secure and scalable backend for our internal CRM/operations portal entirely in Go (Golang).
Workflow & State Management: Design and implement complex backend logic to track multi-stage workflows (e.g., tracking client progress from initial consultation to university admission and visa approval).
Advanced RBAC Implementation: Develop a comprehensive Role-Based Access Control (RBAC) system to manage varying levels of data visibility and permissions for different staff members (e.g., consultants, regional managers, admins).
Secure Document Management: Build secure RESTful APIs for handling the upload, processing, and storage of highly sensitive client documents (passports, academic transcripts, visa applications).
Third-Party Integrations: Integrate external APIs seamlessly into the portal (e.g., email/SMS communication services, calendar scheduling, cloud storage like AWS S3, and potentially payment gateways).
Database Design: Design and optimize relational database schemas (e.g., PostgreSQL or MySQL) capable of handling relational data between clients, tasks, documents, and staff activities efficiently.

Requirements
Senior-Level Golang Expertise: 5+ years of software engineering experience with at least 3+ years of intensive, hands-on experience building production-ready applications in Go (Golang).
Internal Tools / ERP Experience: Proven track record of developing custom CRMs, ERPs, or internal operational portals. You must understand how to translate real-world business workflows into backend state machines.
API & Microservices: Deep expertise in designing clean, well-documented RESTful APIs (or gRPC) to serve modern frontend frameworks (e.g., React, Next.js, or Vue).
Data Security & Privacy: Strong understanding of data encryption, secure file handling, and best practices for protecting Personally Identifiable Information (PII) – a critical requirement for our industry.
Database Mastery: Advanced SQL skills and experience with ORMs/query builders in the Go ecosystem (e.g., GORM, sqlx).
Autonomy: You are a self-starter who can take high-level business requirements ("We need a module to track visa statuses") and independently architect the technical solution.
Communication: Flawless written and spoken English. You will be collaborating directly with stakeholders to refine requirements and demonstrate progress.

Nice-to-Have
Experience deploying Go applications on AWS, Google Cloud, or using Docker/Kubernetes.
Familiarity with building real-time notification systems (WebSockets) for task tracking and updates.

We are building a carbon tokenization platform and are looking for an experienced Full-stack Go (Golang) Blockchain Engineer to help design, develop, and scale our tokenization infrastructure.

This is a exciting opportunity to work at the intersection of blockchain technology and environmental sustainability. The ideal candidate has hands-on experience building blockchain solutions in Full-stack and Go and a strong understanding of tokenization protocols.

Responsibilities:
-Design and develop blockchain components using Full-stack and Go (Golang)
-Build and integrate tokenization infrastructure for carbon credits/assets
-Develop and audit smart contracts
-Collaborate with our team on architecture and technical decisions
-Ensure security, scalability, and performance of the platform

Required Skills & Experience:
-Strong proficiency in Full-stack development and Go (Golang)
-Proven experience in blockchain development
-Experience with tokenization protocols and smart contracts
-Understanding of blockchain architecture and security best practices
-Familiarity with carbon credits / environmental assets (strong plus)
-Preferred Qualifications:
-Experience with Ethereum, Polygon, or other EVM-compatible chains
-Knowledge of IPFS, decentralized storage, or oracle integrations
-Remote

Please include your relevant experience and availability in your proposal

To Apply:
-Submit a brief proposal outlining:
-Your availability and estimated rate

Grade: Senior

Number of Specialists: 1

Engagement Period: 6 months

Specialist Location: Belarus (With VPN), EU, No RF

Work Format: Remote

Time Zone: UTC+2
Rate: Incoming, within the market (in EUR)
Language: Conversational English

❗️A Mac is mandatory for the work❗️
Requirements:
• 5+ years of commercial backend engineering, with experience solving complex problems in high-load environments.
• Strong knowledge of Go, with advanced features applied in practice (generics, reflection, unsafe, custom synchronisation primitives).
• Strong SQL knowledge: schema design, scaling strategies (replication, partitioning, sharding), query optimisation for high-load environments.
• In-depth knowledge of Redis: various data structures and their efficient use in high-load systems.
• Experience with sync/async inter-service communication (gRPC, message brokers), focused on reliability under high load.
• Deep understanding of microservice architecture patterns and efficient client–server interactions, incl. trade-offs and limitations.
• Proven ability to design and implement a full observability strategy: metrics, logging, dashboards, distributed tracing.
• Experience with Docker, CI/CD, Kubernetes (or analogues), cloud infrastructure (AWS or similar).
• Ability to write maintainable, testable code with solid unit/integration test coverage.
• Git proficiency (branching, PRs, code review workflows).
• Experience with collaboration tools (Jira, Azure DevOps).

Must-have skills: Golang development, Redis, gRPC, Microservices Architecture, Docker, CI/CD (Continuous Integration/Continuous Delivery), Orchestrators, Unit Testing, Integration Testing, Git, Jira, Azure DevOps

Responsibilities:
• Design, develop, and maintain robust, scalable, and reliable backend services according to business needs.
• Drive technical research, architecture design, and implementation of backend services and new features.
• Conduct cross-team collaboration to deliver cohesive and optimal solutions.
• Actively participate in code reviews and architectural discussions; help raise the overall technical level of backend services.
• Write clean, effective, and maintainable code based on company standards.
• Take ownership of backend services lifecycle, including delivery, monitoring, and maintaining services in the production environment.
• Set up and maintain observability infrastructure: metrics, logging, dashboards, and tracing.
• Mentor and guide other engineers, advocating for best practices and high standards.
• Participate in agile practices (discovery, refinement, decomposition, sprint planning, demos).

Nice to Have:
• Experience with event-driven architectures (Kafka, NATS, RabbitMQ).
• Familiarity with IaC tools (Terraform, Pulumi).
• Experience with performance profiling/optimisation of Go services (pprof, trace).
• Familiarity with design handoff tools (Figma) and cross-platform collaboration.
• Experience using AI-assisted dev tools (GitHub Copilot, ChatGPT, Claude) to speed up coding/testing/code review.

We are looking for a software engineer with deep knowledge of blockchain technologies to develop and support innovative solutions in the field of crypto processing, blockhain, DeFI, dApps and multy-party computations. Your role will involve research, designing, developing, and testing solutions in secure, high-performance distributed systems for processing cryptocurrency transactions, as well as integrating new functionalities into the company's products like MPC, distributed signing, etc.

*Responsibilities*
- Develop and implement innovative solutions for the company's products in the blockchain and crypto-processing sector
- Write clean, high-quality, maintainable code
- Integrate new functionalities into existing solutions and system architectures
- Integrate blockchain platforms with the company's existing systems
- Conduct code reviews and ensure code security
- Participate in architectural discussions and develop scalable system architectures
- Work with APIs to interact with crypto-payment gateways and external services
- Analyze system performance, identify bottlenecks, and optimize the system
- Participate in the development of new products and services based on blockchain technologies

*Requirements*
- A passion for problem-solving and finding innovative solutions
- At least 4 years of experience as a developer
- Deep knowledge of programming languages: Go, Solidity
- Expertise in Web3
- Experience with version control systems (Git)
- Experience working with blockchain platforms (Ethereum, Solana, Tron, etc.)
- Experience with cryptographic protocols and smart contracts
- Experience with DeFi
- Knowledge of decentralized application (dApps) architectures
- Understanding the specifics of cryptocurrency transactions and smart contracts
- English level: B1-B2

*Nice to Have*
- Experience with financial operations and high-load systems
- Knowledge of containerization and DevOps infrastructure (Docker, Kubernetes)
- Experience with programming languages: Rust, JavaScript, Python

We're hiring versatile senior engineers who own delivery across the full SDLC and have genuinely adopted an AI-assisted way of working. You'll turn ambiguous product direction into production software in days, not weeks, inside a regulated payments environment (DORA, PCI DSS, SOC 2, EMI regulations, GDPR). Our controls shape the SDLC, from change management and approvals to testing evidence and audit trails. We want engineers who work smart within them, not around them. The selection process is hands-on: be ready to show your AI-assisted delivery, not just describe it.

What you'll do

- Own features end to end: design, build, test, deploy and support.
- Work across a polyglot stack (Ruby, Node, Go) plus modern frontend.
- Use AI tooling as a core part of building, reviewing and QA, and help raise the team's practices.
- Stay productive in a large monolith, and use AI-assisted refactoring to improve it incrementally.
- Make the codebase easier for AI assistants to work in (context files, architecture notes, structured docs).
- Turn product specs into precise engineering specs, using proofs of concept to find the level of detail that lets AI-assisted changes land reliably with minimal iteration.
- Deliver within regulatory controls, and propose ways to speed up delivery without weakening them.
- Build security in by default: secure coding, threat modelling, dependency and secrets management, and AI workflows that protect data and the supply chain.
- Run services on AWS (ECS/EKS) with GitHub for source control and CI.
- Handle data analysis, ETL and data QA, supported by AI tooling.

What we're looking for
- Strong full-SDLC engineering track record, with hands-on experience in at least two of Ruby, Node and Go, and good frontend skills.
- Demonstrable evidence of moving your own workflow to AI-driven delivery, with a concrete example of AI-assisted refactoring in a legacy monolith and the judgement to know where AI helps and where it doesn't.
- Experience writing documentation and context that guides AI code assistants.
- Strong product sense and a deliberate methodology for specifying work, shown through practice or portfolio.
- Ownership and self-direction: you unblock yourself and navigate the organisation to deliver.
- Comfort in a regulated environment: you understand the reasoning behind the controls, learn new frameworks quickly, and deliver efficiently without bypassing change control, evidence or audit requirements.
- Solid AWS, containerisation, MySQL (some PostgreSQL), and data analysis/ETL skills.

Skills: Ruby on Rails, Golang, Amazon Web Services, Node.js, PostgreSQL, Ruby, Kubernetes, GitHub CoPilot, AI Development, Claude (Anthropic)

We're looking for a Full-Stack Engineer to build across the breadth of what Somnia ships, from consumer-facing products to developer technologies to internal platform and tooling. One month that's a polished end-user app, the next it's an SDK, a CLI, or the internal systems the rest of the team builds on.

This is a role for someone who cares as much about the product as the code.

You'll own the full lifecycle, from rapid prototyping to deployment. You use AI tools as a multiplier and like shipping end-to-end.

What you’ll be doing

- Design and build production-grade products end-to-end, back-end through UI - across consumer apps, developer-facing technologies and internal platform tooling.

- Build the high-performance back-ends and services these products depend on.

- Create developer technologies - SDKs, APIs, CLIs, libraries and starter kits - that make the platform easy to build on.

- Build internal tooling and platform infrastructure that raises the velocity of the whole team.

- Work self-directed: watch the ecosystem and the team's needs, spot gaps and propose and build what moves things forward.

- Work with DevRel, Marketing and BD so what you build lands with users and developers and fits go-to-market.

What we’re looking for

- Strong TypeScript across the full stack - this is the core of the role and our app stack. Some Golang where it fits.

- Build high-quality, production-ready frontends.

- Strong back-end engineering - APIs, services and the data layer behind them.

- Genuine interest in crypto, Defi and on-chain products.

- Strong ownership and self-direction - you generate ideas, not just execute them.

- Able to turn the dial: prototype fast and loose to prove a feature out, then shift into steady-state mode to harden what's worth keeping - tests, edge cases, reliability.

We're building a kubernetes kvm and vllm virtualization infrastructure and LLM management platform and looking for experienced developers and operators who move quickly, have transitioned to LLM only code, embrace open source and have extensive experience provisioning, managing, and automating virtual machines and related infrastructure in private clouds.

1) You've personally deployed, configured, troubleshot, and automated environments such as VMware vSphere/ESXi, Proxmox VE, Nutanix AHV, Hyper-V, or OpenStack.

2) You have exposure to KubeVirt, KVM, QEMU, or libvirt.

3) You can architect and build API's, integrations and automation using Go and Python on linux.

4) You can turn features and issues in hours not days or weeks.

California only.

Senior Golang / Rust / Solidity / Move developer needed to build ranking system / online assessment system for Students in university.

We are a senior engineering team hiring a backend engineer for our client, a European company that builds AI tools for creators. You will join their product team long term.

The team ships fast. New image and video models reach users within days of release, and engineers are expected to shape what gets built, not only how. You will work directly with their product and engineering people.

What matters most to us
- You have built a product for creators or designers: a design tool, a creative marketplace, a photo, video or audio app, a generative AI platform or something close to it
- You think about the person using the product. You question a feature when it does not serve them and suggest a better one
- You use creative or generative tools yourself and have opinions about what makes them good or frustrating

What you will do
- Build and scale backend services for the lifecycle of AI generations: image, video, audio, 3D
- Run long, resource-heavy generation jobs reliably, with queues, retries and resumable steps
- Bring new models into the product quickly and turn their outputs into features creators actually use
- Work with AWS (EKS, S3, Lambda), Kafka or SQS, gRPC or GraphQL

You should have
- 5+ years of backend work, ideally in Go. If you come from a creator platform and work in another language, apply anyway and tell us how fast you would pick up Go
- Experience owning parts of a production system end to end
- Fluent spoken English for daily work with the client team

The engagement is full time, 40 hours a week, long term. Your working day must overlap with Amsterdam time. Individual engineers only, no agencies.

How we hire: a call with our CTO about your product work and your code, then a call with the client's team. Both are live, with screen share and without AI assistants.

To apply, open your proposal with a link to a creator or design product you helped build and one sentence on what you owned in it. Proposals without it will not be read.

Please keep all communication on Upwork. We do not reply to anyone who contacts us outside the platform.

We’re looking for a SaaS Full Stack Developer to implement a focused set of improvements to an existing AI-assisted SaaS platform following a recent technical audit.

The application is built with Next.js and Node.js and uses OpenAI for document analysis, summaries and recommendations. The core product is already working, so this is not a new build. The work will focus on improving the existing implementation and addressing the main technical priorities identified during the audit.

The initial scope includes:

- Improving the reliability of the OpenAI integration, including structured responses, validation and error handling
- Refining the document-processing flow and handling failed or incomplete requests more clearly
- Addressing selected performance and scalability issues in the current application
- Improving backend logging and visibility into AI-related failures
- Cleaning up the relevant full-stack code where needed
- Adding or updating focused tests for the affected functionality

We’re looking for someone with practical experience in SaaS development, Next.js, Node.js and production AI integrations who can work carefully within an existing codebase.

About the opportunity
Sentient Gaming Group is looking for an experienced software engineer to help develop and strengthen our real-time casino gaming platform.
Our game portfolio includes Roulette, Multiplayer Roulette, BubbleBlast and Baccarat, alongside additional game variants. You will work on an existing platform, delivering new functionality and improving reliability, performance and the player experience.
This is a backend-focused role, with opportunities to contribute to browser-based game clients and integrations. We are looking for someone who enjoys understanding a system end to end and taking ownership of problems from investigation through to a verified solution.

Our current technology stack
- Backend: Node.js/JavaScript and Go.
- Communication and state: WebSockets, gRPC/Protocol Buffers, HTTP APIs and Redis.
- Game clients: TypeScript/JavaScript, Vite, HTML/CSS and PixiJS in parts of the frontend.
- Infrastructure and delivery: AWS, Docker/Docker Compose, Nginx and GitHub Actions.
You do not need to be an expert in every technology listed. Strong engineering fundamentals, relevant production experience and the ability to contribute to an established codebase matter most.

What you will work on
1. Game and platform development
Develop backend functionality, implement new game features and variants, and improve how game clients, platform services and game-logic services work together.

2. Betting, wallet and aggregator integrations
Build and maintain reliable game-launch, session, betting and settlement flows. Handle retries, timeouts and interrupted operations while protecting transaction correctness.

3. Real-time gameplay
Improve WebSocket communication, reconnect behaviour, game-state synchronisation and client-server interactions. Help ensure that gameplay remains responsive and consistent across devices and browsers.

4. Performance and production troubleshooting
Investigate issues across game clients, backend services and infrastructure. Identify bottlenecks affecting game startup, response times and reliability for players in different geographic regions.

5. Testing and safe delivery
Write meaningful automated tests, review changes for unintended effects on other games, verify fixes in development and support controlled production releases.


What we are looking for
You should have strong professional experience with Node.js or Go, together with the ability and willingness to work across both backend stacks. Practical JavaScript/TypeScript and browser-debugging skills are also important.
We particularly value experience with:
- Real-time or distributed systems, asynchronous processing and concurrency.
- Redis, API integrations and reliable transaction handling.
- Investigating problems across browser, backend and infrastructure boundaries.
- Automated testing, code reviews and maintaining production systems.
You should be comfortable entering an unfamiliar codebase, tracing how it works and making focused improvements without unnecessary rewrites.


Experience that would be valuable
Previous experience with iGaming, casino platforms, multiplayer games, fintech or payment systems is an advantage, but direct casino experience is not mandatory.
Experience with game servers, casino aggregator integrations, wallet systems, browser-based game development, observability or gaming certification would also be useful.


The engagement
This is a hands-on engagement through Upwork, with the potential for long-term collaboration.
You will contribute to an active gaming platform and a growing portfolio of games. Beyond completing individual tasks, there is room to identify worthwhile improvements and help shape how we build, test and release our software.


How to apply
Please send a brief introduction focused on a relevant system or project you personally worked on. Explain your contribution, the technologies involved and a difficult engineering problem you solved.
Include your hourly rate, weekly availability, time zone and earliest start date. Public code samples are welcome, but a clear explanation of relevant commercial work is equally useful.
We are more interested in specific examples of your work than a generic cover letter.

I’m looking for a strong Senior Full-Stack Developer with solid AI experience to work with me full-time on a long-term project.

I’m building an enterprise B2B electronic tender and procurement platform. I’m looking for someone who can take real ownership of the technical development, not just complete individual tasks.

The role will be full-time on a monthly salary basis, with the possibility of a long-term position and growth as the project develops.

I’m especially interested in someone experienced with:

* React / Next.js
* TypeScript / Node.js
* PostgreSQL / Supabase
* REST APIs and scalable backend architecture
* SaaS and multi-tenant systems
* Cloud deployment and DevOps
* Security and role-based access control
* AI integration, LLMs, RAG, and AI agents
* Claude / OpenAI and AI-assisted development
* Writing clean, maintainable, and well-tested production code

I will work closely with you on the product requirements, business workflows, and system design. You will be responsible for turning those requirements into a reliable and scalable product.

I’m looking for a long-term working relationship with someone who is proactive, communicates well, takes ownership, and is comfortable using AI tools to significantly improve development speed while maintaining high code quality.

The project has significant potential, and I’m looking for someone who wants to grow with it rather than simply complete a short-term freelance contract.

If you’re interested, please send me a message with:

* A brief introduction about yourself
* Your relevant experience with full-stack development and AI
* Links to your GitHub, portfolio, or previous projects
* Your availability for full-time work
* Your expected monthly salary
* Your preferred communication method

You can contact me directly here on the platform, or email me at: [your email address]

Please use the subject line: Senior Full-Stack Developer – B2B Procurement Platform

I’ll review your information and get back to suitable candidates to arrange an initial discussion

📋 Description
• Serve as an emerging individual contributor within a team while expanding leadership, guidance, and mentoring skills
• Support scope, schedule, and delivery requirements with guidance from leadership
• Collaborate across teams to consolidate and simplify DevOps tools and services
• Solve problems by driving simplicity in architecture and operations
• Complete cloud infrastructure and automated deployment tasks under the direction of a senior engineer
• Build libraries, modules, and packages for infrastructure engineers
• Build cloud infrastructure supporting applications
• Improve the developer experience for engineers
• Support CI/CD processes to deliver higher-quality software faster
• Integrate tools for quality thresholds, security vulnerabilities, and static analysis
• Build application test and deployment pipelines using Jenkins, GitHub Actions, CircleCI, GitLab CI, or similar automated tooling
• Work with government partners and application teams to meet security, SLA, and performance requirements
• Perform DevOps support rotation during business hours and on-call responsibilities beyond business hours

🎯 Requirements
• Bachelor's degree and 5+ years of professional software engineering experience (or equivalent combination of education and experience)
• Hands-on production experience with AWS as a primary cloud provider
• Working proficiency with Kubernetes (EKS or equivalent), including deploying, troubleshooting, and managing containerized workloads
• Proficient with Terraform or comparable IaC tool
• Experience building and maintaining CI/CD pipelines using GitHub Actions, Jenkins, or similar
• Comfortable working in a Linux environment, including shell scripting, systemd, networking basics, and package management
• Background in containerization, virtualization, networking, and load balancing/reverse proxies
• Strong written and verbal communication skills
• Ability to work with other engineers to resolve issues
• Ability to explain technical decisions and tradeoffs regarding complex infrastructure
• Meaningful contributions to planning discussions
• Ability to perform DevOps support rotation during business hours and on-call responsibility beyond business hours
• Ability to successfully complete and maintain any required government background investigation
• Preferred: Direct experience with Terragrunt
• Preferred: Experience with Argo CD / Argo Workflows or other GitOps deployment tooling
• Preferred: Familiarity with HAProxy, OpenResty, NGINX, Envoy, or Kong
• Preferred: Proficiency with Go, Bash, Python, or another scripting/coding language
• Preferred: Experience with GitHub Actions reusable workflows, composite actions, and self-hosted runners
• Preferred: Experience integrating SAST/DAST and dependency scanning into pipelines
• Preferred: Experience in federal/government IT environments, including ATO processes, FedRAMP, or STIGs
• Preferred: Experience building internal developer platforms or golden-path tooling
• Preferred: Experience with observability stacks such as Datadog or CloudWatch

🏖️ Benefits
• Company-subsidized health, dental, and vision insurance
• Flexible PTO
• 401K with employer match
• Paid parental leave after one year of service
• Employee Assistance Program
• Remote work culture and tools