Discover Golang Projects on Upwork with Vollna

Job Description: Mid-Level Full-Stack Cloud Engineer — Remote
We’re looking for a mid-level Full-Stack Cloud Engineer (Individual Contributor) to help us build modern, serverless applications and integrate generative AI features into our product platform.

You’ll design and deliver real-world outcomes—optimizing cloud performance, accelerating feature delivery, and improving AI-assisted workflows for our customers.

You should be deeply familiar with the AWS ecosystem, particularly in building event-driven architectures and leveraging managed AI services.

This is a remote role with an expectation of moderate overlap with Pacific Time (PST).

As part of our engineering team, you’ll collaborate with product designers, data scientists, and AI researchers, reporting to the Engineering Manager. While you’ll primarily work independently, you’ll be part of a close-knit team that values experimentation, transparency, and pragmatic innovation.

Core Responsibilities

- Architect for impact: Design and evolve high-performing, serverless systems on AWS (Lambda, API Gateway, EventBridge) to deliver reliable, low-latency services.
- Handle data intelligently: Model and optimize data using DynamoDB and vector stores, balancing cost efficiency with speed for millions of transactions.
- Integrate next-gen AI: Use AWS Bedrock to orchestrate foundation models (Claude, Mistral), design prompts, and embed AI behaviors that enhance user workflows.
- Deliver full-stack experiences: Build responsive React frontends and Node.js backends that improve user experience and feature velocity.
- Automate with precision: Use AWS CDK or SAM to manage Infrastructure as Code (IaC), and design CI/CD pipelines (GitHub Actions or CodePipeline) that enable fast, stable deployments.
- Collaborate effectively: Partner with designers, product managers, and AI specialists to translate business needs into intuitive, high-value systems.
- Prioritize reliability: Implement monitoring and security best practices to maintain uptime and protect sensitive data.

Technical Requirements

Category
Required Skills & Experience
AWS Core
- 3+ years building production workloads using AWS Lambda, API Gateway, and DynamoDB.

AI/ML
- Practical knowledge of AWS Bedrock (integrating LLMs like Claude)

Frontend & Backend
- Proficiency in Node.js for backend and React for frontend development.

DevOps & IaC
- Familiarity with CDK or SAM, CI/CD pipelines (GitHub Actions, CodePipeline), IAM roles, and VPC configurations.

Security & Observability
- Experience implementing authentication, logging, and monitoring best practices (e.g., CloudWatch, AWS Config).

Preferred Qualifications
- Experience with AWS CDK or SAM for infrastructure deployment.
- Understanding of vector databases and RAG (Retrieval-Augmented Generation) patterns.
- Strong grasp of asynchronous programming and RESTful API design.
- Experience with state management libraries (Redux, Context API).

Nice to Have
- Experience with vector databases and Retrieval-Augmented Generation (RAG) patterns.
- Knowledge of performance tuning and cost optimization in event-driven systems.
- Familiarity with UX-focused engineering, accessibility, and responsive design.

• Pros and cons of Client VPN vs. Bastion Host for private RDS access? How do you use VPC Endpoints?
• How do you handle Lambda Cold Starts, and what are the best practices for securing an API Gateway?
• Explain the difference between a Global Secondary Index (GSI) and a Local Secondary Index (LSI). When would you use DynamoDB Streams?
• What are CloudFormation StackSets, and how do you handle a "Dependency Error" when a stack fails to delete?
• How do you optimize a React app's performance when dealing with large datasets?

Making changes to existing website. hourly base first and maybe long term

Dear Cloud Engineers,

We are currently looking for several Cloud Engineers for one of the leading tech companies in Germany. The position is 100% remote and long-term.

QUICK FACTS:
- Freelancing/Contracting
- Start: ASAP
- 100% remote
- Duration: long-term 12+ months
- Capacity: full-time, part-time also possible
- Language: English
- Project timezone: Philippines

REQUIREMENTS:
- Experience with Microsoft Azure and cloud-based infrastructure.
- Strong knowledge of Kubernetes (K8s) and container orchestration.
- Experience with Infrastructure as Code (e.g. Terraform) and tools like Helm.
- Familiarity with CI/CD pipelines and GitOps (e.g. GitLab).
- Knowledge of scripting (e.g. Bash, Go) and monitoring / incident management.

Are you interested?

If so, please send us your proposal including your most recent CV as well as your earliest possible starting date.
When sending over your details, please include a self-assessment (0-10, 10 = expert level) in the following areas:
- Microsoft Azure
- Kubernetes (K8s)
- Infrastructure as Code (Terraform)
- HELM
- GitLab CI/CD & GitOps
- Go (Golang)
- Bash Scripting
- Monitoring & Incident Management

We are looking forward to hearing back from you. Have a great day!

Your wynwood tech Recruiting Team ;-)

Automate account creation on marketplace website
Build a script that creates new user accounts
Each account must be able to make a purchase
Purchase flow dont need to be automated
9 out of 10 sequential account creations must be able to reach a checkout page after signup
Please propose fixed-price and timeline

Hello, we are looking for an engineer who has successfully setup Prebid Server in the past. Apply only if you have done this before and you know the entire technical implementation from start to finish.

We are seeking a skilled freelancer to develop a Golang script that creates accounts in a PostgreSQL database. The script should accept a JSON payload with user details and insert them into the database. The ideal candidate will have experience in Golang and database management, ensuring efficient and secure data handling.

• If any, for which websites have you done account creation automation in the past ?

About the project
Affiliate Marketing Express is a SaaS platform that audits affiliate-marketing programmes,
generates actionable tasks for brand managers, and automates the day-to-day operations of
affiliate management.
Current scale: 7 active brands, 5-person team, in growth phase.
Why this role matters
Today, generating one brand audit costs roughly 30 hours of manual babysitting per two-week
cycle: open a browser tab, paste a 108 KB prompt, watch for 20–50 minutes, restart on crash,
eyeball quality, manually delete and retry. The platform's growth is bottlenecked on this single
human-in-the-loop.
Your job is to remove that bottleneck — move the audit pipeline to the server, make crashes
visible, prevent quality regressions at the import boundary, and give the team a UI to inspect
and re-run audits without ever opening a browser tab again.
Must-have requirements
• 5+ years backend with TypeScript and Postgres
• Production Supabase experience: Edge Functions (Deno runtime), Row Level Security,
Realtime, Vault, pg_cron, pg_net
• Serverless / edge timeout handling — phase-based loops, self-re-triggering, cache
strategies
• Deep Postgres: migrations, RLS policies, SQL functions, cron jobs, indexing
• Complex auth integration: OAuth, Auth0, 2FA flows, session-cookie management
• Web scraping: Cheerio or Playwright, cookie handling, anti-bot mitigation
• Solid vanilla JavaScript / DOM — the frontend uses no framework
• English fluent
• Clean git discipline: small PRs, conventional commits, working in a documented codebase

Nice-to-have
• Affiliate-marketing domain knowledge (AWIN, CJ, Impact, Rakuten)
• Anthropic Claude API / prompt engineering / prompt caching
• Make.com or n8n automation experience
• Netlify deployment, GitHub Actions CI
What we offer
• Mature codebase with clear conventions — not a greenfield gamble
• Direct access to the founder, no layers, no committees
• Concrete tasks with explicit acceptance criteria
• Full ownership of backend architecture
• Compensation: Budget

We’re looking for an experienced Terraform engineer (ideally with Go + Terraform Provider experience) to help us extend our Terraform provider with support for custom domains.

This is a well-scoped project, but it requires careful handling of Terraform state, computed fields, and validation flows — we’re looking for someone who can follow established patterns and think through edge cases.

What You’ll Work On

You’ll implement support for custom domains in our Terraform provider using a standard DNS verification pattern commonly used by providers like AWS, Vercel, and others.

Concretely, this involves:

- Extending an existing Terraform resource (Go, Terraform Plugin Framework)
- Exposing computed DNS records (e.g. CNAME, TXT) returned by our API
- Implementing a validation/waiter resource that polls until the domain becomes active
- Ensuring correct Terraform graph behavior (dependencies, ordering, lifecycle)
- Writing acceptance tests against our API
- Handling edge cases (normalization, diffs, partial states, etc.)
- Updating our Terraform module documentation to reflect the changes

We are seeking a highly skilled Full-Stack Developer with expertise in Go (Golang), Next.js, and modern AI integrations to build scalable, intelligent web applications. You will work across the stack, developing high-performance backend services and responsive frontend interfaces while integrating cutting-edge AI capabilities.

Key Responsibilities

Design and develop scalable backend services using Go (Golang).
Build modern, performant web applications using Next.js, React, and TypeScript.
Integrate AI/ML APIs (e.g., LLMs, NLP services, recommendation systems) into web applications.
Develop RESTful and/or GraphQL APIs for seamless frontend-backend communication.
Optimize applications for speed, scalability, and security.
Collaborate with cross-functional teams to define and implement new features.
Implement authentication, data protection, and best security practices.
Work with databases (PostgreSQL, MongoDB, or similar).
Deploy and manage applications using cloud platforms (AWS, GCP, or Vercel).
Required Skills

Strong experience with Go (Golang) for backend development.
Proficiency in Next.js, React, and TypeScript.
Experience integrating AI services (e.g., OpenAI APIs, Hugging Face, or similar).
Solid understanding of API design (REST/GraphQL).
Familiarity with databases (SQL/NoSQL).
Knowledge of version control systems like Git.
Understanding of modern DevOps practices (CI/CD, Docker).

What You’ll Build
AI-powered dashboards and web apps
Intelligent chat interfaces and assistants
Data-driven platforms with automation features
Scalable backend systems handling large datasets

The Senior Full Stack Automation Engineer is responsible for the end-to-end design, development, and deployment of a large-scale business automation platform. This role requires a deep command of both frontend and backend engineering, with the ability to architect complex systems that handle high volumes of data, concurrent users, and mission-critical business operations across multiple departments and workflows.

On the frontend, the engineer designs and builds responsive, high-performance user interfaces that allow business users to configure, monitor, and manage automation workflows without requiring technical intervention. The interfaces must be intuitive, reliable, and capable of rendering real-time data at scale.

On the backend, the engineer architects robust server-side systems, RESTful and event-driven APIs, database schemas, and automation logic engines that power the platform. This includes designing for fault tolerance, horizontal scalability, and secure data handling across integrated third-party systems such as CRMs, ERPs, payment processors, and communication platforms.

The engineer owns the full development lifecycle from technical scoping and system design through to testing, deployment, and post-launch performance monitoring. They establish coding standards, review infrastructure decisions, and ensure the platform remains maintainable as it scales in complexity and usage.

This role requires strong experience with modern full stack technologies, cloud infrastructure, containerization, CI/CD pipelines, and automation framework design. The engineer is expected to make high-impact architectural decisions independently and collaborate directly with product, operations, and business stakeholders to translate complex requirements into reliable, scalable software.

The ideal candidate has a proven track record building and shipping enterprise-grade applications, a systems-level mindset, and the technical depth to handle the full weight of a demanding production environment from day one.

Project overview
We have an existing Windows-only Go application — a small daemon that runs on a customer's ERP server, queries their ERP database via ODBC (and/or reads CSV exports), and uploads the results to AWS S3 on a schedule. The lower-level plumbing (ODBC → CSV → S3 upload, S3 download, SQLite jobs CRUD, daily-at-time scheduling) works. Everything wrapping it — the UI, the setup flow, ERP detection, login, templates, error handling — is missing or built on a now-unmaintained Qt binding (therecipe/qt, Qt 5.13).

We've finished a complete v2 UX redesign and want a freelancer to build the new app in Wails (v2), reusing the existing primitives but writing most of the application logic and the entire UI from scratch. The HTML/CSS mockups for every screen are already in the repo (mockups/) and serve as pixel-accurate references for the Wails frontend.

Why Wails
- Backend stays in Go — we keep the working primitives.
- Frontend is HTML/CSS/JS, which is exactly what the mockups are already, so visual fidelity is straightforward.
- Single-binary Windows .exe, native window chrome, system tray.
- Maintained framework, modern stack, large talent pool.

What's already there (reuse)
- ODBC connectivity via alexbrainman/odbc and database/sql (Progress OpenEdge tested; MSSQL/Postgres/Oracle drivers wireable).
- AWS S3 upload/download/list via aws-sdk-go (s3_manager.go).
- SQLite jobs store (database.go) — schema is small and easy to migrate.
- gocron-based "daily at HH:MM" scheduler (server.go).
- Existing Job model: JobType (Upload_Database / Upload_File / Download_File), Name, Driver, Query, LocalPath, S3Bucket, S3Path, ExecTime, DeleteFile.
- Run-once "test query" endpoint that runs an ad-hoc SELECT and returns CSV.
- Modification-time cache so unchanged files aren't re-uploaded.

What does NOT exist yet (build)
- Login + per-customer config fetch. Today, AWS creds, region, etc. come from a local config file. v2 needs a login screen that calls our backend API (we'll provide the spec; for now mock it) and pulls S3 buckets, client ID, and short-lived credentials.
- ERP detection. No detection code exists — needs to be written from scratch: registry scan (HKLM Uninstall keys), ODBC DSN enumeration, filesystem probes for known export folders, running-process checks via gopsutil. Confidence scoring per candidate.
- ERP templates. Concept of "active ERP" + a template that auto-generates the initial set of jobs (queries, schedules, data types) — see mockups/06_jobs_review.html for an OPTIback example. Templates need to live somewhere updatable (likely fetched from our backend; cache locally).
- Data-type taxonomy. Replace free-text S3Path with a bounded enum: Transaction Data, Item Master Data, Availability, Inventory Data, Promotion Data, Article Mapping, Store Master Data. Daemon derives the S3 key from (bucket, data_type, client_id). One job can carry multiple data types (see plan.md and the multi-pill design in 06_jobs_review.html).
- Per-job last-run tracking. Status (ok / failed / running / pending / never), last-run timestamp, last error message. Surfaced in the job table.
- System tray + popup. Persistent tray icon when the main window is minimized; popup showing the live status of running/recent jobs (see 09_daemon_tray.html).
- Error states. Login fail, detection-empty, job-fail, credentials-expired flows (see 10_error_states.html).
- Default / unsupported ERP path. Manual ERP picker + generic CSV-drop checklist when detection is skipped (see 05_erp_setup_instructions.html, "Mode B").
- Test-from-row + "Test all enabled" buttons in the jobs table (existing test-query endpoint can be reused; no per-job test runner yet).
- Windows installer. We have a bat file that registers a scheduled boot task; a real signed NSIS (or equivalent) installer needs to be built.
- Schema migration for the existing SQLite jobs table (add data_type[s], last_run, last_status, last_error, ERP slug, etc.).

Mockup references
- 7 finished screens in mockups/ — open mockups/index.html. Covers installer, login, ERP detection, ERP-side setup (two modes), job review (with create/edit modals + tray-minimize), daemon tray, error states.
- plan.md in the repo root for the data-type taxonomy and known mapping decisions (incl. tentative mappings flagged for review).

Scope of work
1. Stand up a new Wails (v2) project structure inside the repo. Single binary that is both the foreground UI and the background daemon (toggled by a flag or by tray-icon presence).
2. Implement each screen from mockups/ as the Wails frontend, faithful to the mockups. Frontend framework is your call — vanilla TS, React, Svelte, etc. The HTML/CSS in mockups/ is your starting point.
3. Build the missing backend pieces listed above (login & config fetch, ERP detection probes, ERP-template loading and job generation, data-type-driven S3 key derivation, per-job last-run tracking, system tray integration, error flows, schema migration).
4. Reuse the existing S3/ODBC/scheduler primitives. Light refactoring is fine; please flag any larger refactors before doing them.
5. Replace the existing Qt UI and Qt-based IPC. The old Qt files (client.go, create_job_dialogs.go, job_table_widget.go, qml/, the QLocalSocket layer in network.go and server.go) can be removed once the Wails app reaches feature parity with the mockups.
6. Package as a signed Windows installer that also registers the scheduled boot task.
7. Pass our CI (.github/workflows/ci.yml).

Out of scope
- The customer-facing backend API (we own that; you'll consume a documented spec — and a mock during dev).
- Mac / Linux builds — Windows only.
- Visual redesign. Stick to the mockups; flag pragmatic deviations in the PR.

Deliverables
- PRs against main: a Wails-based app reaching feature parity with the mockups, with the new functionality wired to working code (or, where unavoidable, to clearly-labeled stubs we agree on up front).
- Old Qt/QML UI and Qt-IPC removed once parity is reached.
- Updated build/release pipeline with a signed Windows installer.
- Short README section on running and building locally.

Required skills
- Wails v2 (must have shipped at least one Wails app on Windows).
- Strong Go — most of this job is writing Go: detection probes, schema migrations, scheduler glue, tray integration, IPC redesign.
- Comfortable with HTML/CSS/JS (or TS); your choice of framework.
- Bonus: Windows Registry / WMI APIs, ODBC, AWS SDK, NSIS or comparable installer tooling, code signing, Windows scheduled tasks.
- Working English.

How to apply
Please include in your proposal:
1. 2–3 sentences on Wails apps you've shipped, with links/screenshots if possible.
2. Your preferred frontend stack inside Wails and why.
3. Rough estimate (hours or fixed price) and timeline. Per-area breakdown welcome — the cost split between UI work and the new backend pieces is the most useful number for us.
4. How you'd approach ERP detection on Windows specifically.
5. Any clarifying questions about the mockups or plan.md.

Repo will be shared with shortlisted candidates.

Budget & timeline
- Budget: hourly band
- Target start: ASAP