Boost Grafana Projects with Vollna's Tools

I need a cloud-hosted program, built entirely on AWS, that can inflate YouTube views, inject likes, and post pre-written comments several times a day without tripping Google’s abuse filters. We will start with YouTube only; once that is running smoothly I may extend the same framework to Instagram and website traffic, so keep the architecture modular.

Core requirements
• AWS-native: the whole workflow should deploy through CloudFormation or Terraform and run headlessly on EC2/Lambda containers, with CloudWatch keeping logs.
• Actions: generate realistic view sessions, apply likes, and drop comments I supply via a simple JSON list. Each action should be throttle-controlled so total engagement can be set per hour and the combined activity mimics human behaviour (variable delays, randomised watch times, rotating residential proxies, etc.).
• Frequency: schedule bursts multiple times per day and allow me to edit the schedule from an S3-hosted config file.
• Metrics dashboard: a lightweight panel (could be in CloudWatch Logs Insights, Grafana, or a small React page) that shows how many views, likes and comments were sent and whether any requests were blocked.
• Deliverables: production-ready code, deployment script, brief README, and a recorded demo proving the tool can push engagement on a test video without being flagged.

I already have AWS credentials and proxy subscriptions; you bring the coding, scaling know-how and a strategy to keep the click-through rate within a custom range.

If this sounds straightforward to you, let’s talk time-frame and milestones.

Skills: Linux, Cloud Computing, NoSQL Couch & Mongo, Amazon Web Services, Node.js, JSON, AWS Lambda, Terraform

Server & Network Infrastructure Architect – Secure On-Prem Environment for AI, Data, Storage & Security

We are a growing organization that runs 24/7 across multiple departments, with about [150–300] staff users and highly sensitive, regulated data. We are planning a complete on-premise IT infrastructure (with optional hybrid cloud) and need an experienced architect to design it end to end.

This is not just web hosting. We need one secure, scalable environment that covers application hosting, AI workloads, data processing, analytics, storage, network security and access control.

CURRENT SETUP
- Web application: .NET REST API backend + Next.js frontend, with real-time features (SignalR)
- SQL database with sensitive personal and operational records
- Users on the local network and at remote locations
- Plans to run AI models locally so sensitive data never leaves our premises

SCOPE OF WORK

1. Server & Application Hosting
- Physical server sizing (CPU, RAM, storage) for current load and 3–5 years of growth
- Virtualization or container platform (Proxmox, VMware, Hyper-V, Docker, Kubernetes)
- Hosting for the .NET API, Next.js frontend, databases and background services
- Load balancing, reverse proxy, SSL, and separate environments (production, staging, UAT)

2. AI Infrastructure
- GPU server sizing for running LLMs and AI models locally (inference, possibly fine-tuning)
- Model serving stack recommendations (e.g., vLLM, Ollama, Triton)
- Keeping AI workloads isolated and secure from the core systems

3. Data Processing & Analytics
- Database architecture: primary/replica, high availability, performance tuning
- Data warehouse / reporting server kept separate from live transaction data
- ETL pipelines and BI/dashboard tools (e.g., Power BI, Metabase, Superset)

4. Storage, Backup & Disaster Recovery
- NAS/SAN design, RAID levels, capacity planning for documents, images and large files
- Backup strategy (3-2-1 rule, immutable/offline backups, ransomware protection)
- Disaster recovery plan with clear RPO/RTO targets and failover design

5. Network & Cybersecurity
- Firewall selection and setup (e.g., FortiGate, Sophos, pfSense/OPNsense)
- Network segmentation using VLANs (servers, staff, guest Wi-Fi, IoT-type devices, CCTV, AI servers)
- IDS/IPS, endpoint protection, SIEM / centralized logging and monitoring
- Patch management, vulnerability scanning, security hardening baseline

6. VPN & Access Control
- Site-to-site VPN between branches and remote-access VPN for staff and vendors
- Identity management (Active Directory / Azure AD / LDAP), SSO and MFA
- Role-based access control, least-privilege policies, privileged access management
- Audit trails: who accessed which data, and when

7. High Availability & Physical Infrastructure
- UPS, power redundancy, dual internet links with automatic failover
- Server room / rack layout, cooling and environmental monitoring
- Uptime monitoring and alerting (e.g., Zabbix, Grafana, Prometheus)

8. Compliance & Governance
- Design aligned with data-privacy and security best practices (encryption at rest and in transit, data retention, access logging)
- Documentation that can support future security audits

DELIVERABLES
- High-level and detailed architecture diagrams (network, server, data flow)
- Hardware and software bill of materials with recommended brands/models and estimated costs
- Security architecture document (firewall rules approach, VLAN plan, access-control model)
- Backup & disaster recovery plan
- Phased implementation roadmap (what to build first, what can wait)
- Optional: cloud vs on-prem vs hybrid cost comparison

REQUIRED EXPERIENCE
- 7+ years in infrastructure, systems or network architecture
- Proven work designing environments for data-sensitive, 24/7 organizations (finance, government, healthcare, large enterprise, etc.)
- Hands-on experience with firewalls, VPNs, VLANs, virtualization, NAS/SAN and backup systems
- Knowledge of on-prem GPU/AI server deployment is a strong plus
- Security certifications (CISSP, CCNP, CCNA Security, CEH, AWS/Azure Architect, etc.) are a plus
- Clear communicator who can explain technical decisions to non-technical management

IN YOUR PROPOSAL, PLEASE INCLUDE
1. A similar infrastructure you designed or built: the scale, number of users, and your role
2. How you would design remote vendor access without exposing internal servers
3. Your recommended approach for protecting backups from ransomware
4. Whether you have deployed AI/LLM models on local hardware, and which setup you used
5. Your estimated timeline and rate for the design phase

I have seven freshly racked Ubuntu bare-metal servers on the same private network and I want them production-ready before the weekend is over.

Architecture to build
• 3 servers become the application tier: you will install the exact PHP and Node.js versions I will provide, configure them behind Cloudflare’s load balancer (active-active) and stand up a three-node Redis cluster.
• 4 servers form the data tier: MySQL and Postgres must run in a highly-available cluster on these four machines. All application traffic—internal and external—should arrive through HAProxy, which you will configure for read/write awareness and fail-over.

Monitoring & dashboards
Grafana (with Prometheus, node exporter, MySQL, Postgres and Redis exporters) needs to be in place on every box, charting CPU, memory, uptime, LAN/WAN traffic per interface, plus live “top queries” panels for MySQL, Postgres and Redis.

What I will hand you
– The exact version list for PHP, Node.js, MySQL and Postgres.
– SSH access to each server and Cloudflare credentials.

Success means that by Monday Morning at 10:30 in India I can:
1. Push a PHP or Node app and reach it through the Cloudflare VIP.
2. Write to either database engine and watch HAProxy route correctly.
3. See all requested metrics on the Grafana dashboards.

If you have recent hands-on experience with Ubuntu server automation, HAProxy tuning, database clustering and Grafana observability, this should be a fast, clean weekend build.

Skills: Linux, MySQL, Node.js, Network Administration, Redis, Scripting, Server, DevOps, Cloudflare, Cluster Computing

Title: Fixed Budget: Python Dashboard Developer for Algorithmic Trading API
Budget: ₹50,000 (Fixed Price Milestone-based)

Project Overview:
I am looking for a freelance fintech developer to construct a lightweight trading dashboard. The goal is to track live portfolio performance, compute essential risk metrics, and monitor execution health in real time.

Technical Scope:
- Framework: Must be built using a Python framework (Streamlit or Plotly Dash preferred) or Grafana.
- API Connectivity: Fetch continuous account stream data from [Insert your broker name, e.g., Alpaca / Zerodha].
- Key Visual UI Elements: Live P&L chart, open positions ledger, execution logs window, and key statistical widgets (Sharpe ratio, Maximum Drawdown).

Requirements:
- Proven experience with financial web APIs and WebSockets.
- Must provide brief examples or screen recordings of prior trading dashboards built.

I’m rolling out a new Asterisk-based PBX that spans both an on-prem rack server and a small cloud instance. I need a specialist who can take the project from a clean slate to a fully functional, production-ready system.

Here’s what I’m expecting:
• Complete installation of the latest stable Asterisk on each node (one local, one cloud) with SIP trunks registered and ready.
• Seamless call routing between sites, extension dialing, voicemail, IVR, and basic queue logic operating flawlessly across the hybrid topology.
• Secure configuration—TLS/SRTP, strong authentication, sensible firewall rules, fail-over settings between the two servers.
• Real-time monitoring and alerting set up (Nagios, Zabbix, Grafana, or a tool you’re comfortable with) so I can track call quality, trunk status, disk/CPU, and receive instant notifications on issues.
• Clear, concise hand-over documentation and a quick walkthrough so I can maintain day-to-day tasks internally.

Acceptance criteria:
• Both servers pass test calls (internal, external, fail-over) without packet loss or noticeable latency.
• All configured services appear clean—no critical alerts—on the monitoring dashboard for 48 consecutive hours.
• Documentation is delivered in an editable format and accurately reflects the live environment.

If you’ve built hybrid Asterisk systems before and can move fast while keeping things tidy, let’s get started.

Skills: Linux, Asterisk PBX, VoIP, Telecommunications Engineering, Debian, Network Administration, Alerting, SIP

Senior AI/ML + Distributed Systems Engineer Required (Enterprise Build – $45,000 Fixed Price)

Project: AI Financial Intelligence & Risk Monitoring Platform

We are hiring a highly experienced engineer or engineering team to architect, build, deploy, and operationalize a production-grade AI Financial Intelligence & Risk Monitoring Platform.

This is not a prototype.
This is not a simulation.

This must be a fully scalable, real-time, enterprise-grade system capable of operating under production conditions.

⸻

Project Overview

The platform must:

* Process high-volume financial data streams in real time
* Detect anomalies using AI-driven models (not rule-based systems)
* Generate actionable risk intelligence
* Operate under strict performance, latency, and scalability benchmarks

Mock pipelines, placeholder logic, or simulated outputs will be treated as non-delivery.

⸻

Budget & Payment Structure – $45,000 Fixed

$40,000 – Advance Payment (Testing Phase Funding)

* Paid upfront upon project commencement
* Intended to fund development, infrastructure, and execution

Important:

* This payment does not constitute delivery, acceptance, or completion
* It does not waive any performance, scope, or deployment requirements
* It does not limit the Client’s rights in the event of non-delivery or breach

⸻

$5,000 – Final Payment

* Payable only upon:
* Full production deployment
* All systems operational and accessible
* All performance benchmarks achieved
* Transfer of:
* Source code
* Models
* Infrastructure access
* Documentation

Failure to meet these conditions voids entitlement to the final payment.

⸻

Scope of Work (Mandatory Deliverables)

Failure to deliver any core component constitutes non-delivery.

Data Ingestion & Processing

* Distributed ingestion pipeline (Kafka + Spark Streaming)
* High-throughput real-time data handling
* Data validation and preprocessing pipelines

Feature Engineering

* Feature store implementation
* Real-time and batch feature pipelines

AI & Risk Intelligence

* Hybrid anomaly detection (statistical + LSTM models)
* Ensemble-based risk scoring engine
* Real-time inference capability

Rule-only systems, hardcoded logic, or simulated outputs do not qualify.

⸻

Explainability Layer

* SHAP (or equivalent)
* Transparent and interpretable model outputs

⸻

Backend & API

* FastAPI-based architecture
* Secure APIs (OAuth2 / JWT)
* Scalable, modular backend design

⸻

Frontend Dashboard

* React-based analytics dashboard
* Real-time data visualization
* Full integration with backend services

⸻

Infrastructure & Deployment

* Kubernetes-based deployment
* CI/CD pipelines
* Monitoring stack (Prometheus, Grafana)
* Staged rollout strategy

Local-only or non-scalable deployments do not qualify.

⸻

Testing & Validation

* Stress testing under load
* Production-readiness verification

⸻

Performance Requirements (Mandatory)

The platform must meet all of the following benchmarks:

* ≥ 50,000 events/sec ingestion throughput
* ≤ 2 seconds ingestion latency
* ≤ 50 ms feature retrieval latency
* ≥ 90% anomaly detection precision
* ≤ 80 ms scoring latency
* ≤ 400 ms API response time
* ≤ 1.5 seconds dashboard load time

Failure to meet these metrics constitutes non-delivery.

⸻

Service Reliability Requirements

* Target uptime: 99.5% monthly availability

Exclusions include scheduled maintenance, force majeure, external infrastructure failure, and unauthorized usage.

Support Expectations

Working hours: 09:00–18:00 GMT/BST

Response and resolution:

* Critical: 4-hour response / 24-hour resolution
* Major: 8-hour response / 48-hour resolution
* Minor: 1 business day response / 5 business days resolution

⸻

Delivery & Acceptance Standard

Delivery is complete only when:

* Platform is fully deployed in production
* All scope items are fully functional
* AI models produce real, verifiable outputs
* Performance benchmarks are achieved
* Monitoring and CI/CD systems are operational
* Documentation is delivered
* Full source code, credentials, and infrastructure access are transferred

Anything less constitutes non-delivery.

⸻

Data, Security & Compliance

The Contractor must implement commercially reasonable safeguards aligned with:

* ISO 27001
* SOC 2 (Type I / II)
* PCI (where applicable)

All work must comply with applicable data protection laws, including GDPR where relevant.

The Contractor may use anonymized, aggregated data where legally permitted.

⸻

Intellectual Property

Upon final payment:

* All deliverables, including source code, models, and documentation, become the property of the Client

The Contractor retains ownership of:

* Internal tooling
* Deployment frameworks
* Generic infrastructure components

The Client retains full ownership of all data and datasets.

⸻

Confidentiality

Both parties agree to maintain strict confidentiality over:

* System architecture
* Pipelines and models
* Data and integrations

This obligation survives termination.

⸻

Refund Rights (Material Breach)

Failure to deliver a complete, production-ready system constitutes material breach.

This includes:

* Missed delivery obligations
* Non-functional system
* Failure to meet performance benchmarks
* Failure to deploy to production

The Client reserves the right to terminate and pursue recovery of payments subject to applicable terms and governing law.

⸻

Suspension Rights

The Contractor may suspend services if:

* Payments are overdue beyond 30 days
* Agreement breach occurs
* Unauthorized usage is detected
* Security risks arise

⸻

Limitation of Liability

Liability is limited as defined under applicable governing terms.

Nothing excludes liability for:

* Death or personal injury due to negligence
* Fraud
* Non-excludable statutory obligations

⸻

Force Majeure

Neither party is liable for delays caused by events beyond reasonable control, including:

* Natural disasters
* War
* Infrastructure failures
* Pandemics

⸻

Communication Requirement

All communication, updates, approvals, and documentation must occur exclusively via Upwork messages.

Off-platform communication does not amend this Agreement.

⸻

Governing Law

This agreement is governed by the laws of England and Wales.

All disputes fall under the exclusive jurisdiction of the courts of England and Wales.

⸻

Strict No Partial Acceptance Clause

* No partial acceptance of work
* No payment for incomplete or partially functional systems
* “Substantial completion” or “near completion” does not qualify
* Completion of individual modules does not entitle proportional payment
* Milestones, testing, or feedback do not constitute acceptance

Acceptance occurs only upon full system completion.

⸻

Who Should Apply

Applicants must demonstrate:

* Proven experience building production-grade distributed systems
* Deep expertise in real-time data pipelines
* Experience deploying AI/ML systems at scale
* Strong command of Kafka, Spark, Kubernetes, FastAPI, and React

⸻

Application Requirements

Include the following:

1. Relevant production systems (not demos)
2. High-level architecture approach
3. Team structure (if applicable)
4. Estimated timeline

⸻

Final Note

This is a high-stakes, enterprise-grade build.

Failure to deliver a complete, production-ready system that meets all requirements will result in the project being treated as non-delivered.

Skills: Data Processing, Cloud Computing, Machine Learning (ML), Spark, Kubernetes, Anomaly Detection, API Development, CI/CD, FastAPI, Distributed Systems

We are seeking an experienced DevOps & Cybersecurity Engineer (or DevSecOps specialist) to design, automate, and harden our cloud infrastructure and deployment pipelines. The ideal candidate will bridge the gap between rapid delivery and robust security, ensuring our systems are scalable, compliant, and protected against modern threats.

Key Responsibilities

CI/CD & Automation: Build, maintain, and optimize secure CI/CD pipelines (GitHub Actions, GitLab CI, or Jenkins) for automated testing, container builds, and zero-downtime deployments.

Infrastructure as Code (IaC): Provision, manage, and audit cloud infrastructure (AWS, GCP, or Azure) using Terraform, Ansible, or CloudFormation.

Containerization & Orchestration: Manage containerized environments with Docker and Kubernetes, ensuring proper cluster networking, access controls, and resource limits.

Security Hardening & Compliance: Implement least-privilege IAM policies, manage secret rotation (Vault, AWS Secrets Manager), and enforce network segmentation, firewalls, and encryption at rest/in transit.

Vulnerability & Threat Management: Integrate automated security scanning (SAST/DAST, container image scanning, dependency audits) into deployment workflows and conduct periodic vulnerability assessments.

Monitoring & Incident Response: Set up centralized logging, alerting, and observability (Prometheus, Grafana, Datadog, or ELK Stack) to proactively detect anomalies and respond to security events.

Required Skills & Qualifications

Proven experience in a DevOps, DevSecOps, or Cloud Security role.

Strong proficiency with at least one major cloud provider (AWS, Azure, or GCP).

Deep hands-on knowledge of Terraform, Docker, and Kubernetes.

Solid background in Linux/Unix administration, Bash scripting, or Python.

Practical understanding of security frameworks, network protocols, and secure SDLC practices.

Relevant certifications (e.g., CKA, AWS Certified DevOps/Security Specialty, CISSP, or CompTIA Security+) are a strong plus.

How to Apply
Please share a brief summary of your relevant experience, a link to your GitHub or portfolio if available, and an example of a past project where you successfully balanced deployment speed with tight infrastructure security.

We run a multi-region Oracle estate (US, LATAM, MEA, APAC) behind a connected-mobility
platform — online charging (OCS), billing (BSS), and high-volume transactional workloads.
We're looking for a senior Oracle DBA to take ownership of steady-state operations and,
more importantly, to automate them away.

ENGAGEMENT
- Hours: [X] hrs/week, ongoing
- Required overlap: [HH:MM–HH:MM UTC] — the rest of your hours are yours to schedule
- On-call: [none / rotational, compensated separately — be specific]
- Start: [date]
- Long-term intent: yes. We are not looking for a one-off fix.

WHAT YOU'LL DO

Daily operations
- Health checks across regional instances: alert logs, tablespace and ASM diskgroup
growth, session and wait-event analysis, blocking locks, invalid objects, failed jobs
- Backup and recovery: RMAN policy execution, scheduled restore-testing (not just
"the job succeeded"), retention, archive log management
- Monitoring and alerting: tune thresholds, eliminate false positives, close the loop on
any alert that fires more than twice
- Space, growth, and capacity forecasting per region
- User, role, and privilege administration under least-privilege; support for access reviews
- Change execution in approved windows: schema deployments, DDL, index and stats maintenance

Performance and reliability
- SQL and instance tuning: execution plans, AWR/ASH/ADDM analysis, SQL profiles and
baselines, partitioning strategy for high-volume charging and billing tables
- Billing-cycle support: pre-run readiness checks, live monitoring during bill runs,
post-run cleanup
- High availability: RAC administration, Data Guard configuration and switchover/failover
testing, replication (GoldenGate or equivalent) health
- Patching: quarterly RU/PSU planning and execution with rollback paths; version upgrades

Automation and documentation
- Convert recurring manual checks into scripts, scheduled jobs, or dashboards. We track
how much manual toil you remove — it's how we evaluate the engagement.
- Maintain runbooks, SOPs, and DR documentation so anyone on rotation can run the
routine path
- Incident response and blameless RCAs with concrete corrective actions

REQUIRED
- 5+ years administering production Oracle (12c/19c or later) in 24x7 environments
- RMAN backup AND restore — including at least one recovery you performed under pressure
- RAC, ASM, and Data Guard hands-on: configuration and failover you personally executed,
not "exposure"
- Performance diagnosis: AWR interpretation, plan reading, and the judgment to tell a
query problem from a schema problem from a hardware problem
- Bash scripting and SQL/PL-SQL; comfortable on Linux (RHEL/OEL)
- Clear written English and the discipline to document as you go

NICE TO HAVE
- Telecom OSS/BSS, charging, mediation, or high-volume billing systems
- MySQL administration (you will touch it)
- Automation beyond scripts: Ansible, Terraform, or Grafana/Prometheus/Zabbix

HOW WE HIRE
1. Proposal + answers to the questions below
2. 45-minute technical call: a recovery scenario and a live AWR report to diagnose
3. Paid 20-hour trial on non-production, scoped to monitoring and diagnostics
4. Ongoing contract, with production access granted after NDA and security clearance

ACCESS AND COMPLIANCE
Production access requires a signed NDA and a background check. Some regional systems
carry data-residency conditions; access to those is granted only after clearance.
Please confirm you're able to work under these terms.

Please start your proposal with the word ORACLE so we know you read the post.
Copy-paste proposals will not be reviewed.

Linux Systems Administrator
Job Type: Full-Time
Location: Killeen, Texas
Department: Systems Support

Job Summary
We are looking for an experienced Linux Systems Administrator to administer, monitor, secure, and maintain enterprise Linux environments. The ideal candidate will have strong hands-on experience with RHEL, Ubuntu, and CentOS, along with familiarity with Windows Server, VMware, and containerized environments such as OpenShift and Kubernetes.

This role will provide Tier 2/3 technical support, troubleshoot complex infrastructure issues, support enterprise applications, and collaborate closely with development, DevOps, and security teams.

Key Responsibilities
Administer, monitor, maintain, and troubleshoot Linux systems, including RHEL, Ubuntu, and CentOS.
Install, configure, secure, and optimize Linux services such as systemd, SSH, Apache/Nginx, cron, and related services.
Perform Linux system upgrades, patching, configuration, and security hardening.
Provide Tier 2/3 support for escalated server and infrastructure issues.
Identify, research, and implement Linux and OpenShift solutions and applications.
Support and troubleshoot enterprise applications and their underlying server environments.
Manage Linux security administration in collaboration with information security teams.
Monitor system health, performance, availability, and capacity, and proactively address potential issues.
Collaborate with development, DevOps, infrastructure, and security teams to support application and infrastructure requirements.
Provide technical guidance and support to IT teams on Linux configuration and administration.
Maintain awareness of Linux and OpenShift updates, changes, and new releases, and communicate relevant changes to stakeholders.
Work with vendors and internal teams to resolve technical issues and support applications and infrastructure.
Create and maintain accurate technical documentation, processes, and standard operating procedures.
Participate in a weekly on-call rotation to respond to after-hours infrastructure issues.
Travel to other data centers or company locations as required.
Perform other duties and assignments as needed.
Windows Server & Virtualization
Provide administration and support for Windows Server environments and related services.
Working knowledge of Active Directory, Group Policy, DNS, DHCP, and PowerShell.
Administer VMware vSphere/ESXi environments, including:
Virtual machine deployment
Resource management
VM administration
Snapshots
Basic troubleshooting
OpenShift & Containerization
Support and administer OpenShift/Kubernetes environments.
Install, configure, maintain, upgrade, monitor, and troubleshoot OpenShift/Kubernetes clusters.
Support containerized applications using OpenShift, Kubernetes, or Docker.
Stay current with developments, updates, and best practices in container orchestration technologies.
Security & Compliance
Ensure compliance with security standards, patching schedules, and organizational policies.
Apply security hardening practices to Linux and server environments.
Understand common web application and infrastructure vulnerabilities, risks, and appropriate countermeasures.
Work closely with security teams to identify and remediate security issues.
Maintain confidentiality of sensitive customer, business, and internal information.
Required Qualifications & Skills
Bachelor's degree in Computer Science, Computer Engineering, Information Technology, or a related field preferred. Equivalent relevant experience may be considered.
Strong hands-on experience administering Linux servers, preferably RHEL, Ubuntu, and/or CentOS.
Strong troubleshooting and analytical skills with the ability to independently research and resolve complex technical issues.
Experience with Linux system administration, configuration, patching, and security.
Knowledge of Windows Server administration and core services.
Familiarity with VMware vSphere/ESXi.
Knowledge of web/application server technologies such as Apache and Nginx.
Understanding of server and web application security principles.
Ability to manage multiple priorities and meet project deadlines.
Strong written and verbal communication skills.
Ability to collaborate effectively with technical and non-technical stakeholders.
Ability to work independently as well as part of a broader IT team.
Willingness to participate in an on-call rotation.
Preferred Qualifications
Experience with OpenShift, Kubernetes, and/or Docker.
Experience installing, configuring, upgrading, monitoring, and troubleshooting OpenShift/Kubernetes clusters.
Familiarity with CI/CD pipelines, Git, and DevOps practices.
Experience with Infrastructure as Code (IaC) tools such as Terraform and Ansible.
Experience with monitoring and logging platforms such as Prometheus, Grafana, ELK, or Splunk.
Familiarity with Linux security hardening and patch management.
Certifications such as RHCSA, RHCE, CKA, CKAD, or OpenShift certifications are a plus.
What We're Looking For
We are looking for someone who is technically strong, security-conscious, and comfortable working across Linux infrastructure, virtualization, and modern containerized environments. The ideal candidate should be proactive, capable of handling complex production issues, and able to collaborate effectively across IT, DevOps, development, and security teams.

Senior Full-Stack / Platform Developer – Delphi, APIs & Integrations
About eProd Solutions
Kenyan AgTech eProd Solutions builds and delivers practical agricultural supply chain management software platforms for financial services, agricultural value chains, traceability, and operational data management. Our systems are used in real business environments where reliability, data integrity, security, and maintainability matter.

We are a small, growing development team with several junior developers. We are looking for a senior hands-on developer who can operate at technical-lead level, take ownership of complex work, and help raise the capability of the wider team.

This is not a narrowly defined feature-development role. The successful developer will contribute across architecture, backend and frontend development, integrations, deployment, troubleshooting, documentation, testing, and mentoring.

The projects you will work on
Our current delivery work includes two technically demanding solution areas.

The first is a financial-services platform that connects web, mobile, and USSD channels with customer and farmer data, loan-limit and scoring services, reporting dashboards, SMS notifications, and third-party systems. The architecture includes REST APIs following OpenAPI principles, an API gateway, independently deployable services, asynchronous messaging, caching, MySQL data storage, monitoring, high-availability design, and disaster-recovery procedures.

The second is a digital traceability and farmer-data platform for a Nigerian cocoa supply chain. It supports hundreds of thousands of farmers across cooperatives, zones, and community groups. The platform includes Android field operations, offline-capable data capture and synchronisation, GPS points and farm polygons, inspections, farmer and farm master data, EUDR-readiness records, receipts, supply-chain transactions, dashboards, audit trails, role-based access, controlled exports, and public view-only traceability.

The technical environment includes Java, Delphi 12 for mobile and backend services, ReactJS, REST/OpenAPI APIs, MySQL, RabbitMQ, Redis, Nginx, Linux/Ubuntu, Prometheus/Grafana, Docker, Git-based workflows, CI/CD, and cloud infrastructure. We also work with Java/Spring Boot and other complementary technologies where appropriate.

What you will do
Under the supervision of the Chief Technology Officer, you will help design, build, maintain, and improve production-grade applications and services across the eProd product portfolio.

Your responsibilities will include:

• Designing and implementing maintainable backend services, APIs, business workflows, and integrations.
• Working across Java and Delphi services and applications, React-based web interfaces, and mobile or offline-synchronisation workflows.
• Translating business and operational requirements into clear technical designs and implementable work items.
• Building and integrating REST APIs using consistent contracts, validation, authentication, authorisation, and error handling.
• Integrating external systems such as banking, payment, customer-data, CRM, SMS, USSD, reporting, and traceability platforms.
• Working with MySQL data models, queries, validation rules, data-quality processes, and migration or import workflows.
• Using RabbitMQ or comparable messaging technologies for asynchronous processing, retries, background jobs, and reliable delivery.
• Using Redis or comparable caching approaches where they improve performance and reduce unnecessary database load.
• Contributing to secure deployment and operations on Linux/Ubuntu and cloud infrastructure, including Nginx, certificates, backups, monitoring, and recovery procedures.
• Improving observability through structured logging, metrics, dashboards, alerts, health checks, and useful operational documentation.
• Writing automated tests and participating in code review, debugging, quality assurance, release preparation, and production support.
• Reviewing technical designs and code from junior developers, explaining trade-offs, and helping the team adopt stronger engineering practices.
• Creating concise technical documentation that makes systems easier to operate, support, and extend.
• Communicating risks, dependencies, estimates, and technical decisions clearly to the CEO, project stakeholders, and development team.

Required experience and capability
We are looking for evidence of senior-level ownership, not only a list of technologies. You should be able to demonstrate most of the following:

• Several years of professional software-development experience, including responsibility for production systems.
• Strong backend development skills in Delphi, Java/Spring Boot, or another comparable strongly typed backend environment.
• The ability to understand and improve an existing codebase rather than only create isolated greenfield applications.
• Practical experience designing service-oriented or microservice-style systems and REST APIs.
• Strong relational-database experience, preferably MySQL, including schema design, data integrity, query performance, and troubleshooting.
• Experience integrating third-party APIs and diagnosing failures across system boundaries.
• Strong understanding of authentication, authorisation, role-based access, secure data handling, TLS/HTTPS, input validation, and auditability.
• Experience with asynchronous processing, queues, scheduled jobs, retries, idempotency, and failure handling.
• Experience deploying or supporting applications on Linux and working with source control and CI/CD pipelines.
• Ability to investigate production issues systematically using logs, metrics, traces, database evidence, and reproducible tests.
• Strong written and spoken communication, with the ability to explain technical issues to both technical and non-technical stakeholders.
• A willingness and ability to mentor junior developers through practical code reviews, pairing, design discussions, and technical guidance.

Important technology note
Delphi 12 is an important advantage because it is part of our current mobile and backend environment. Candidates with strong Delphi experience will be prioritised. We will also consider a senior developer with deep Java/Spring Boot or equivalent backend experience who can demonstrate strong architecture and integration skills and has a credible plan to become productive in Delphi quickly.

Valuable additional experience
The following would strengthen your application:

• Delphi 12 mobile development or cross-platform mobile development.
• Offline-first mobile applications, device identity, secure synchronisation, conflict handling, and intermittent-connectivity workflows.
• GPS data, farm polygons, GIS exports, GeoJSON, KML, shapefiles, or other geospatial data workflows.
• Financial-services, payment, banking, credit-scoring, USSD, SMS, or mobile-money integrations.
• Agricultural traceability, supply-chain, EUDR-readiness, compliance, or audit-trail systems.
• ReactJS and practical frontend development for dashboards, administration portals, and reporting workflows.
• RabbitMQ, Redis, Prometheus, Grafana, Nginx, Docker, AWS, Jenkins, GitLab CI/CD, or similar tooling.
• Power BI, Tableau, SQL reporting, data imports, data cleansing, or data-quality remediation.
• Experience working with small teams where a senior developer must make sound decisions independently and still keep stakeholders informed.

What success looks like
During the first three months, success will mean that you can understand our architecture and codebase, deliver production-quality work with limited supervision, improve the reliability and clarity of at least one important area, and become a dependable technical reference for the junior developers.

Over time, you will help eProd Solutions deliver secure and maintainable systems faster, reduce avoidable defects and operational issues, strengthen our engineering standards, and ensure that technical decisions remain aligned with real customer and project requirements.

How to apply
Please include the following in your proposal:

1 A brief introduction explaining why this role matches your experience.
2 Two or three examples of production systems you personally designed, built, integrated, or supported. For each example, state your specific contribution, the main technologies, and the most difficult technical problem you solved.
3 Your experience with Delphi, if any, Java/Spring Boot, or an equivalent backend language. If you have not used Delphi, explain how you would approach becoming productive in a Delphi 12 codebase.
4 One example of an external API integration or distributed workflow that required retries, error handling, authentication, or reconciliation.
5 One example of a production incident or difficult defect that you investigated and resolved.
6 One example of how you mentored, reviewed, or raised the quality of less-experienced developers.
7 Your weekly availability, preferred hourly rate, and the hours during which you can overlap with East Africa Time.
8 A link to relevant GitHub, portfolio, technical writing, or other work samples, subject to confidentiality restrictions.

Please begin your proposal with the words “Production systems first” so we can confirm that you read the full brief.

Initial technical discussion
Shortlisted candidates should be prepared for a practical technical discussion covering one or more of the following:

• Designing a secure API gateway and service boundary for mobile, web, and USSD clients.
• Modelling a reliable integration with an external banking or customer-data system.
• Handling offline mobile capture and later synchronisation.
• Designing queue-based processing with retries and idempotency.
• Diagnosing a slow or intermittently failing production service.
• Improving a junior developer’s implementation without taking away ownership.

We are interested in how you reason, communicate trade-offs, and protect system reliability—not only in whether you can recite framework terminology.

About the Role
Your job is developer enablement, and it is hands-on: you own the integration and automation layer of an enterprise internal
developer platform built on Port.io. You will write the services and connectors that pull the platform's data together, build the
workflows behind every self-service action using GitHub Actions and Temporal, maintain the reusable pipeline templates
and embedded quality gates other teams consume, and operate the containerised runtime it all runs on.
Key Responsibilities
• Integration development: Write the integration services and custom connectors that connect the platform to
ServiceNow (approvals, CMDB), identity, observability, cloud platforms and the delivery toolchain, using
TypeScript or Node.js and Python with the Ocean framework.
• Catalogue data: Build and maintain the ingestion that keeps the software catalogue accurate and current across
source control, cloud platforms and enterprise systems.
• Workflow orchestration: Build the automation behind self-service actions, using GitHub Actions for standard
workflows and Temporal for durable orchestrations.
• Pipeline products: Build reusable, versioned CI/CD pipeline templates consumed as golden paths.
• Developer enablement: Unblock developers on pipelines, environments, tooling and automation, and make the
supported approach the simplest one to follow.
• Integration runtime: Deploy and operate the self-hosted integration workloads, such as Ocean-based connectors
and event listeners, as containerised services on Kubernetes.
• Performance testing capability: Operate and improve the k6 framework, covering its GitHub workflow
integration, Kubernetes execution model and Grafana and InfluxDB visibility, and onboard engineering teams to it.
• Quality gates: Integrate security scanning (Wiz, Checkov, OPA), testing and cost tooling so the gates apply by
default.
Required Skills
• CI/CD depth: 10+ years in DevOps or platform engineering with advanced GitHub Actions experience, covering
reusable workflows, composite actions, secrets and runner strategy. Equivalent platforms are fine if you are happy to
standardise on Actions.
• Kubernetes: Solid working Kubernetes.
• Scripting and APIs: Strong scripting in TypeScript, Node.js, Python or Go, and automation against REST APIs and
webhooks.
• Software engineering: Production coding ability, not just scripting: services and integrations written in TypeScript
or Node.js and Python, with the testing, review and documentation discipline that implies.
• API integration: Building and consuming REST APIs, webhooks and event-driven integrations against enterprise
systems, including authentication flows, rate limits and failure handling.

• Enablement mindset: A track record of supporting and unblocking development teams, treating automation as a
product with users.
• Pipeline security: Building security into pipelines: secrets management, least-privilege runners and service
identities, and dependency and IaC scanning as enforced gates.
• Test automation in CI: Integrate automated testing into pipelines.
Preferred Skills
• Durable orchestration: Temporal preferred. Airflow, Step Functions or Argo Workflows transfer well.
• IaC: Terraform and IaC pipeline integration.
• Performance testing: k6, Gatling, JMeter or Locust. Any load-testing background transfers well.
• Ecosystem: Port.io or Backstage exposure, the Ocean framework or comparable connector frameworks, JQ for data
mapping, and ServiceNow integration.
• Security: Container and Kubernetes security.
Technologies & Tools
The platform environment:
• Developer portal: Port.io, or a Backstage background: catalogue, blueprints, self-service actions and scorecards,
with configuration-as-code in JSON and YAML. Custom integrations use the Ocean framework in Python, plus the
Port API and Terraform provider.
• Languages: TypeScript, Node.js and React, with Python for custom integrations and JQ for data mapping.
• Orchestration: GitHub Actions, with Temporal for durable workflows.
• Delivery toolchain: GitHub and Terraform, an IaC quality and security stack (Wiz, Checkov, OPA, tflint, Infracost,
Terratest), and k6 performance testing running on Kubernetes.
• Integrations: ServiceNow for approvals and CMDB, observability tooling, and enterprise identity and RBAC.

Job Description
Keep client environments running at 99.9%+ uptime and lead incident response across Swift Tech Co.'s SRE function, the person paged first (via PagerDuty) when an SLO burns, and the person who makes sure it burns slower next time, with real DORA metrics tracking whether that's actually happening
Responsibilities
• Own SLOs and error budgets for managed client environments
• Build and improve alerting with Prometheus, Grafana, and PagerDuty so pages are actionable, not noise
• Instrument services with OpenTelemetry and use distributed tracing (Tempo or equivalent) to find root cause fast
• Lead postmortems for major incidents and track remediation items to completion
• Track and report on DORA metrics (deploy frequency, lead time, change failure rate, MTTR)
across client environments
• Partner with engineering teams on reliability reviews before, not after, a service ships

Skills: Python, Linux, Cloud Computing, Docker, Site Reliability Engineering, CI/CD, Incident Response

Job Description

Own infrastructure that keeps Swift Tech Co. client platforms reliable at 99.95%+ uptime across multiple AWS regions, part of the Cloud Infrastructure team supporting projects across FinTech, SaaS, and Al Automation engagements.
You'll be the person other engineers page when something's on fire, and the person who makes sure the same fire doesn't start twice, tracked against real DORA metrics, not vibes.

Responsibilities
• Manage Terraform-defined infrastructure across staging and production for multiple client projects, with Ansible or Pulumi for configuration where Terraform alone isn't the right tool
• Operate and improve EKS-based Kubernetes clusters, including Helm chart maintenance and rollout strategy
• Improve CI/CD pipeline reliability and speed across engineering teams, tracked against DORA metrics (deploy frequency, lead time, change failure rate,
MTTR)
• Build observability with Prometheus, Grafana, Loki, and OpenTelemetry so incidents get caught before customers notice
• Run vulnerability and dependency scanning (Trivy, Snyk) as part of the deploy pipeline, not a quarterly afterthought
• Manage secrets with Vault, and keep IAM/network policy tight across client environments
• Run blameless postmortems and turn findings into concrete infrastructure changes, with runbooks a teammate on-call at 3am can actually follow

Skills: Amazon Web Services, Docker, Prometheus Monitoring, Kubernetes, Network Security, Ansible, Terraform, CI/CD

We ship a small SDK that partner apps embed. With the user's explicit consent it lets the device act as a node in a peer-to-business network (bandwidth-sharing category; think Honeygain or Bright SDK). It runs as a background service or child process and must be invisible in terms of performance, honest in terms of consent, and clean on uninstall.

Today every release is tested by hand. Your job is to change that: build an automated regression suite that covers every SDK build on every platform we ship (Android AAR, Unity plugin for Mono and IL2CPP, Windows DLL and exe wrapper in 32- and 64-bit, Linux), wire it into CI, and then own it. Every release candidate gets an automated pass and a clear go/no-go report before it reaches partners.

What you'll build:

- Instrumented sample host apps per platform (some already exist).
- Functional suite: init, consent accept and decline, opt-out really stops all activity (verified by traffic capture and process state, not by a flag), background service and its notification, handshake with our servers, traffic counted on our stats endpoint, status API, safe unload and re-init, update over a previous version, uninstall leaves nothing behind (files, services, scheduled tasks, registry).
- Stability automation: 12-24 h soak runs with memory/CPU/thread/handle sampling and pass/fail thresholds. A partner once caught our child process at several GB; your suite should catch that before partners do.
- Network scenarios: connection loss and switch, VPN or proxy on the device, sleep/Doze, IPv6-only.
- CI: pipelines on self-hosted runners (Windows 10/11 in 32- and 64-bit, Linux) plus real Android devices and emulators; Unity sample builds in batch mode; reports (Allure or similar), flake control.
- A release gate: one pipeline that takes a build and answers "safe to ship or not, and why".

You:

- 4+ years in test automation for native mobile or desktop software or SDKs, not web-only.
- Android: instrumented tests (Espresso / UIAutomator or Appium), adb scripting, emulator management, real low-RAM devices.
- Windows: PowerShell or Python, process and service control, Sysinternals, performance counters, silent install and uninstall verification.
- Comfortable building a test harness from scratch in Python (pytest) or TypeScript; Linux scripting.
- Network-level verification: tcpdump/Wireshark, mitmproxy; you can assert "this process sends no traffic" programmatically.
- Unity: can build a sample project in batch mode for Mono and IL2CPP and run tests against it.
- CI/CD: GitHub Actions, GitLab CI or Jenkins with self-hosted runners; you have set up device-connected runners before.
- English for reports and docs; Russian is a plus.

Nice to have: testing VPN/proxy/P2P products, antivirus false-positive triage, Docker for Linux matrices, pywinauto or Appium Windows driver, Grafana for soak metrics.

Engagement: milestone-based build-out first (harness + Android in CI, then Windows and Linux, then Unity and soak automation), then ongoing hourly to maintain, extend and gate releases. Long-term.

To apply, please include: (1) an automation framework you built from scratch for a non-web product: platforms, stack, CI, and what it caught; (2) in a few sentences, how you would automatically verify that opt-out stops all network activity, on Android and on Windows; (3) availability and time zone. Put the word "harness" at the top of your proposal.

Senior Golang Developer — Proxy Infrastructure & Networking

We are looking for an experienced Golang developer to continue development and maintenance of an existing high-performance proxy infrastructure platform.

The core software is already built in Go (Golang), so we are looking for someone who can quickly understand an existing codebase, identify issues, and implement new features reliably.

What you’ll work on

* High-performance HTTP/HTTPS/SOCKS5 proxy infrastructure
* Proxy gateways and routing
* Residential proxy traffic management
* Session and sticky-session handling
* Country, state, city and ASN targeting
* Proxy authentication and credential management
* Traffic routing and load balancing
* Connection management and concurrency
* Monitoring, logging and error handling
* Performance and stability improvements
* API integrations
* Infrastructure scaling and optimization

Current challenges

The software is already operational, but we need a developer who can take ownership of the codebase and improve its reliability.

Some areas we want to improve include:

* Preventing unexpected downtime
* Improving connection stability
* Handling high levels of concurrent connections
* Optimizing resource usage
* Improving gateway reliability
* Better error handling and recovery
* Improving monitoring and debugging
* Making the system easier to maintain and scale

Requirements

Must have:

* Strong professional experience with Golang
* Experience with high-concurrency networking applications
* Strong understanding of TCP/IP, HTTP and SOCKS5
* Experience building or maintaining proxy/networking software
* Experience with APIs and backend systems
* Understanding of Linux server environments
* Ability to work with an existing production codebase
* Strong debugging and troubleshooting skills

Nice to have:

* Experience with residential proxy infrastructure
* Experience with proxy gateways
* Experience with load balancing and traffic routing
* Experience with distributed systems
* Experience with Redis, PostgreSQL or similar systems
* Experience with Docker/Kubernetes
* Experience with Prometheus/Grafana
* Experience optimizing high-throughput Go applications

Important

This is not a greenfield project. The software already exists and is written in Golang.

You will first need to understand the existing architecture and codebase before making changes. We are looking for someone who can work independently and take technical ownership rather than simply implementing isolated tasks.

What we expect

* Clean and maintainable code
* Proper testing before production deployment
* Clear communication
* Detailed explanations of important changes
* Ability to investigate production issues
* Reliable and long-term cooperation

To apply

Please provide:

1. Your experience with Golang networking projects
2. Examples of similar systems you have worked on
3. Your experience with proxy infrastructure, if any
4. Your hourly rate
5. Your availability per week
6. Your GitHub or relevant portfolio, if available

We are looking for a long-term developer, not someone for a one-off task.

Senior Laravel and Go developer, long-term contract. Affiliate marketing SaaS, iGaming clients.

We're a small contracting outfit. Most of our clients are in iGaming affiliate marketing: affiliate networks, a few large publishers, and the in-house affiliate programs of operators. Over the years some of that client work turned into SaaS products that we now maintain and run ourselves, mostly around tracking, attribution and commission reporting. We need one more senior developer to share that load, on a contract basis, for a long time if it works out.

Laravel carries the application side: affiliate and advertiser portals, admin panels, the APIs, commission and payout logic, and the importers that pull player activity out of operator reporting systems in whatever shape they export it. Go carries the parts that have to be fast and never fall over: click and redirect handling, postback ingestion, deduplication, and the event pipeline behind the reports. Postgres on most projects, MySQL on the older ones, Redis, ClickHouse for reporting where the volumes justify it. Containers everywhere, Kubernetes for the larger clients and plain Docker on VMs for the rest, Terraform and Ansible underneath. GitLab CI. Grafana and Prometheus for monitoring, plus whatever the client already had.

What we're looking for
You've spent years in production with both Laravel and Go and can switch between them in the same week. You've written and operated a Go service that took tens of thousands of requests a second. On the Laravel side you know the framework deeply, including where its conventions stop being helpful, and you keep PHPStan strict and the tests running because the codebases we inherit rarely came with either.

You understand affiliate tracking properly. First and last click, cookie and click windows, server-to-server postbacks versus pixels. Money math where rounding matters is routine for you, and you'd never store it as a float.

Enterprise-grade, for us, means our clients audit us. You should be comfortable answering a security questionnaire honestly, keeping audit logs a compliance officer can read, handling personal data under GDPR without being reminded, and deploying in a way that can be rolled back at two in the morning.

Useful but not required: integration experience with established affiliate platforms such as MyAffiliates, Income Access, NetRefer, Cellxpert or Affilka. Also WordPress at scale for content sites, GA4 with BigQuery, and Metabase.

Project Title

Build an AI-Powered Cross-Platform Security Monitoring & Incident Response System

Project Description

I am looking for an experienced cybersecurity and full-stack developer to build a modern AI-powered Security Operations Center (SOC) platform for my final-year engineering project.

Project Requirements

- Cross-platform endpoint monitoring (Windows, Linux, and macOS)
- Collect system logs, security events, and network activity
- Real-time threat detection and alert generation
- AI-powered incident analysis using an LLM
- Interactive dashboard for monitoring all connected devices
- Role-based authentication (Admin and Analyst)
- Asset inventory management
- Vulnerability scanning integration
- Malware detection support
- IOC (Indicators of Compromise) detection
- MITRE ATT&CK mapping
- Incident response playbooks
- Report generation (PDF/CSV)
- REST API for communication between components

Preferred Technology Stack

- Frontend: React or Next.js
- Backend: FastAPI (Python)
- Database: PostgreSQL
- Cache: Redis
- Message Queue: RabbitMQ or Kafka
- Search & Analytics: Elasticsearch
- Dashboard: Kibana or Grafana
- AI: OpenAI API or open-source LLM
- Containerization: Docker
- Deployment: Docker Compose

Deliverables

- Complete source code
- Database schema
- API documentation
- Installation guide
- Architecture diagram
- Well-commented code
- Testing documentation
- Deployment instructions
- 30 days of post-delivery support

Experience Required

- Cybersecurity
- Python/FastAPI
- React
- SIEM concepts
- Docker
- AI/LLM integration
- REST API development

Please include examples of similar cybersecurity or AI projects you have completed, your estimated timeline, and your total project cost.

Skills: Java, Python, Linux, Software Architecture, AI Chatbot Development, AI Model Integration, AI Development, AI Automation

We are looking for a Research AI Engineer / Voice AI Engineer with strong hands-on experience in ASR, TTS, LLMs, GPU optimization, and production-grade model deployment.

Our goal is to build and operate a highly scalable, real-time voice AI platform capable of supporting 1000+ concurrent voice calls with low latency and high reliability.

You will work on both AI research/model optimization and production engineering, including deploying open-source ASR, TTS, and LLM models, optimizing GPU inference, and extending models to support new languages and voices.

What You'll Work On
Deploy and optimize open-source ASR, TTS, and LLM models for production.
Build highly scalable inference infrastructure capable of supporting 500+ concurrent voice calls.
Work with LiveKit and real-time voice communication pipelines.
Optimize end-to-end voice latency, including:
Time to first audio
Time to first token
Streaming ASR latency
TTS generation latency
GPU utilization
Concurrent request throughput
Benchmark models under high concurrency and identify bottlenecks.
Optimize inference using technologies such as vLLM and other modern GPU inference/runtime technologies.
Implement batching, continuous batching, dynamic batching, KV-cache optimization, quantization, parallelism, and GPU memory optimization where appropriate.
Deploy models across GPU servers and design production-grade inference architectures.
Monitor and troubleshoot GPU utilization, memory consumption, latency, throughput, and failures.
ASR & TTS Research

We need someone who understands more than simply calling an existing model API.

You should have experience with the underlying ASR/TTS models and training pipelines, including:

Fine-tuning ASR models.
Fine-tuning and training TTS models.
Preparing and cleaning speech datasets.
Audio preprocessing and feature extraction.
Speaker/voice data preparation.
Adding support for new languages.
Improving pronunciation and multilingual performance.
Adding or adapting new voices/speakers.
Understanding phonemes, tokenizers, vocabularies, alignments, and language-specific challenges.
Evaluating WER/CER for ASR.
Evaluating TTS quality, speaker similarity, pronunciation, naturalness, and latency.
Troubleshooting model hallucinations, pronunciation issues, repetitions, and audio artifacts.
Production Infrastructure

You should be comfortable taking a research model and turning it into a production-ready inference service.

Experience with the following is highly desirable:

vLLM
LiveKit
Docker
Kubernetes
Linux
GPU servers
NVIDIA CUDA
PyTorch
FastAPI / gRPC
Redis / messaging systems
Prometheus / Grafana or equivalent monitoring
Distributed inference
Load testing and concurrency testing
CI/CD
Cloud GPU infrastructure

Experience with SGLang or similar high-performance LLM inference/runtime frameworks is also strongly preferred.

Senior DevOps Engineer – 5+ Years Experience | Full-Time | Karachi

We are looking for an experienced DevOps Engineer to join our team on a full-time basis in Karachi, Pakistan.

Key Requirements

• 5+ years of hands-on DevOps experience
• Strong experience with AWS/Azure/GCP
• Expertise in CI/CD pipelines – Jenkins, GitHub Actions, GitLab CI, etc.
• Strong knowledge of Docker & Kubernetes
• Experience with Terraform / Infrastructure as Code (IaC)
• Good understanding of Linux administration & shell scripting
• Experience with monitoring and logging tools such as Prometheus, Grafana, ELK, CloudWatch, etc.
• Strong understanding of cloud infrastructure, networking, security, and scalability
• Experience managing production environments and deployments
• Ability to troubleshoot infrastructure and deployment issues independently

Position Details

📍 Location: Karachi, Pakistan
💼 Employment: Full-Time
🧑‍💻 Experience: 5+ Years
⚡ Joining: Immediate / Short Notice Preferred

Who We're Looking For

We need someone who can take ownership of DevOps and cloud infrastructure, improve deployment processes, maintain system reliability, and work closely with our development team.

Important: Please apply only if you are based in Karachi and available for a full-time role.

How to Apply

Please share:

- Total DevOps experience
- Current location
- Current & expected salary
- Notice period / earliest joining date
- Cloud platforms you have worked on
- Your experience with Kubernetes, Docker, Terraform, and CI/CD

Need someone who can help me to migrate from grafana to dynatrace so need some one who can help me into this ?

Our production systems run on a dedicated PostgreSQL database server that needs ongoing, professional management to keep performance high and downtime at zero. I need an experienced PostgreSQL administrator to take charge of routine upkeep, monitoring, and rapid incident response so the team can stay focused on product development.

Scope of work
You’ll handle version updates, configure and verify automated backups, watch key metrics, fine-tune queries and indexes when bottlenecks appear, and strengthen security by keeping roles, permissions, and network rules tight. The server is Linux-based and accessed via SSH; fluency with psql, pgAdmin, and common monitoring stacks (Prometheus, Grafana, or similar) will make the job straightforward.

Deliverables
• Initial health audit with actionable findings
• Fully tested automated backup & restore workflow
• Performance tuning changes applied and documented
• Security hardening checklist completed and signed off

Acceptance criteria
All deliverables must be published in a succinct report, include before/after benchmarks where relevant, and be reproducible through provided scripts or configuration files.

When you reply, focus on your direct PostgreSQL experience—especially any production-level database server work involving high availability, replication, or large data sets. A concise summary of past roles or projects is all that’s needed; no lengthy proposals required at this stage.

Skills: System Admin, Linux, MySQL, Database Administration, PostgreSQL, Database Management, Performance Tuning, Incident Response

We are looking for an experienced Azure Terraform / DevOps Engineer to design, automate, deploy, and manage cloud infrastructure on Microsoft Azure using Infrastructure as Code.
Strong hands-on experience with Microsoft Azure cloud services.
Strong experience with Terraform for Infrastructure as Code (IaC).
Develop and maintain reusable Terraform modules for Azure infrastructure.

Denizen Blu Compute Marketplace, Reach & Beacon

Start: Immediately
Production Completion Deadline: September 14, 2026
This deadline is non-negotiable.

Overview

Parinita is building the Denizen Blu Compute Supply Marketplace, a production-grade global system that allows individuals, enterprises, hosting companies, data centers and other infrastructure owners to make unused CPU, GPU and accelerator capacity available to Denizen Blu.

We already have the architecture and an existing codebase.

We need a very senior engineering team capable of taking the existing implementation through final integration, hardening, testing and production deployment by September 14, 2026.

This is not:

a prototype
a proof of concept
a demo
a UI-only marketplace
an architecture consulting engagement
a six-week discovery project

The required output is working production code deployed and passing acceptance tests by September 14, 2026.

If you cannot immediately allocate senior engineers and work against this deadline, please do not apply.

What We Are Building

The Denizen Blu marketplace creates a global supply network for AI compute.

The operating flow is:

Provider joins
→ connects CPU/GPU/NPU hardware
→ Parinita Reach enrolls and attests the machine
→ hardware is benchmarked and qualified
→ provider offers available compute
→ Parinita bids for capacity
→ provider accepts
→ capacity becomes available to Denizen Blu
→ BluRoute determines workload placement
→ Beacon resolves the appropriate L7 runtime endpoint
→ workload executes inside the Denizen Compute Runtime
→ usage is securely metered
→ provider sees earnings in real time
→ usage settles weekly
→ provider generates/accepts settlement
→ Ramp handles AP/payment
→ accounting flows downstream

The supplier sells compute capacity to Denizen Blu, not directly to Denizen Blu customers.

Existing Architecture

The architecture has intentionally separated responsibilities.

Denizen Blu Compute Marketplace

Owns:

Provider onboarding
Hardware/node registration
Compute inventory
Supply offers
Provider asking prices
Parinita bids
Bid acceptance
Capacity contracts
Provider dashboard
Parinita buyer/admin console
Real-time earnings display
Weekly settlement presentation
Provider invoice/payment workflow
Provider reputation and operational history
Parinita Reach

Reach is our endpoint identity, trust and remote-operation layer.

Reach owns:

Endpoint enrollment
Machine/workload identity
Hardware attestation lifecycle
Heartbeats
Health
Service publication
Typed remote operations
Revocation
Quarantine
Fleet lifecycle
Agent rollout
Marketplace node-state integration

Reach does not own global workload placement.

Reach must not introduce a separate VPN or competing network architecture.

Provider machines initiate connectivity outward.

Parinita Beacon

Beacon is our deterministic Layer-7 service/workload destination-selection system.

Beacon owns:

Candidate endpoint construction
Tenant hard filtering
Service matching
Sovereignty/compliance eligibility
Health eligibility
Deterministic scoring
Stable tie-breaking
Versioned topology
Decision evidence
L7 publication intent

Beacon must return an explicit failure if there is no compliant endpoint.

Beacon does not own global compute placement.

BluRoute

BluRoute is already the placement brain for Denizen Blu.

BluRoute decides:

Which provider
Which region
Which capacity pool
Which silicon
Which compute class
Which runtime
Which qualified infrastructure

Do not create another scheduler.

The marketplace provides additional qualified supply to BluRoute.

Private Transport

Reach consumes a provider-neutral Private Transport layer.

The underlying transport implementation must remain abstracted and replaceable.

Do not expose underlying infrastructure vendors in the marketplace architecture.

Do not build another VPN product.

Denizen Compute Runtime

The marketplace requires a secure runtime deployed onto supplier hardware.

It must:

Receive authorized Denizen Blu workloads
Isolate workloads from the host
Allocate CPU/GPU/NPU resources
Enforce RAM limits
Enforce storage limits
Enforce network policy
Report health
Meter actual resource use
Produce authoritative usage telemetry
Securely destroy temporary workload state
Support signed upgrades
Support rollback
Drain safely
Recover following interrupted updates

Neither side should be able to compromise the other.

The provider must not have access to Denizen customer workloads.

Denizen workloads must not have arbitrary access to the provider's machine.

BluSettle

BluSettle is the authoritative Denizen Blu usage and cost-attribution layer.

Every dollar owed to a provider must trace to:

BluRoute Job
→ Provider
→ Capacity Contract
→ Node
→ Resource
→ Usage interval
→ Contract rate
→ Amount earned
→ Weekly settlement
→ Payment

Duplicate usage and duplicate settlement must be impossible.

Weekly Provider Payments

Providers are paid weekly.

Required workflow:

Weekly close
→ reconcile authoritative usage
→ calculate settlement
→ display amount to provider
→ provider generates/accepts invoice
→ Ramp payable created
→ Parinita approval
→ payment
→ payment status returned to marketplace
→ accounting synchronization downstream

Ramp is the AP/payment layer.

QuickBooks is downstream accounting and is not the usage or marketplace ledger.

Bare-Metal Compute

Some marketplace hardware may arrive with no operating system.

We therefore need a production bare-metal provisioning path:

Hardware claim
→ ownership authorization
→ bootstrap
→ signed Parinita image
→ boot
→ Reach enrollment
→ hardware attestation
→ qualification
→ Denizen marketplace activation

Initial requirements include ARM64/RK3588-class distributed edge systems and multi-node chassis.

Hardware-specific provisioning must use adapters.

Do not hard-code the platform around one hardware vendor.

Current Codebase

An existing source package already includes substantial implementation for:

Marketplace backend
Provider APIs
Provider dashboard
Parinita buyer/admin console
Reach
Beacon
Database schema
Alembic migrations
Usage receipts
Weekly settlements
Ramp integration boundary
BluRoute integration boundary
Private Transport abstraction
Bare-metal provisioning boundary
Kubernetes deployment artifacts
Docker deployment
OpenAPI specifications
Security documentation
Runbooks
Acceptance gates
Automated tests

You will receive the existing source immediately after engagement.

The expectation is to review quickly, preserve good existing implementation, fix what is required, complete the missing production integrations and deploy.

Do not spend several days redesigning the product.

Required Work
1. Marketplace

Complete and production-harden:

Provider onboarding
Provider identity
Node lifecycle
Supply offers
Bid/counter-bid workflow
Capacity contracts
Provider dashboard
Earnings calculations
Buyer/admin console
Weekly settlements
Invoice lifecycle
Audit logs
OIDC
RBAC
Rate limiting
Idempotency
HA
Transactional outbox
Metrics/logs/traces
Production deployment
2. Reach

Complete:

Enrollment
One-time enrollment credentials
Workload/device identity
Attestation verification
Signed agent communications
Replay protection
Heartbeats
Health
Service registry
Typed operation broker
Revocation
Quarantine
Agent update mechanism
Canary deployment
Rollback
Fleet operations

A provider must not be able to self-certify its hardware.

Unattested or quarantined machines must not receive workloads.

3. Beacon

Complete:

Versioned topology
Candidate generation
Hard eligibility filters
Deterministic scoring
Stable tie-breaking
Health/capacity signals
Route evidence
Publication adapter
ACK/NACK behavior
Explicit no-compliant-endpoint handling
Failure recovery
Rollback
Performance testing

Hard constraints must execute before optimization.

4. BluRoute Integration

Bind the marketplace to the actual Denizen Blu interfaces for:

BluIndex
BluRegistry
BluRoute
BluSettle
Capacity availability
Provider status
Provider certification
Runtime dispatch
Usage
Cost attribution

Marketplace capacity must appear as qualified Denizen Blu supply.

BluRoute remains the sole global placement authority.

5. Provider Compute Runtime

Complete/harden:

Linux runtime
Container isolation
CPU allocation
GPU allocation
NPU support where applicable
Memory quotas
Ephemeral storage
Network controls
Job lifecycle
Health reporting
Usage telemetry
Secure workload cleanup
Node drain
Signed upgrades
Recovery
Crash handling
6. Billing & Ramp

Complete:

Signed authoritative usage
Contract-rate enforcement
Usage reconciliation
Weekly close
Settlement adjustment
Provider acceptance
Ramp vendor mapping
Payable creation
Approval state
Payment webhook handling
Payment failure handling
Idempotency
Downstream accounting synchronization
7. Bare-Metal Provisioning

Complete framework for:

Hardware claim
Ownership validation
Node/chassis discovery
Bootstrap
Image manifest
Signature verification
ARM64 image installation
BSP adapters
A/B image updates
Rollback
Recovery
Reach enrollment following boot
Production Deadline
September 14, 2026

This means deployed, tested and operational, not "code complete."

We expect the selected team to begin immediately and operate on a compressed production sprint.

Indicative execution:

September 7–8
Codebase takeover, environment deployment, interface validation, blockers eliminated.

September 9–10
Reach, Beacon, Marketplace and BluRoute integration paths operational.

September 11
Compute Runtime, Private Transport integration and node lifecycle operational.

September 12
Usage, BluSettle, weekly settlement and Ramp workflow operational.

September 13
Failure testing, security testing, load testing, rollback, observability and acceptance remediation.

September 14
Final production acceptance, documentation, runbooks, deployment handoff and GO LIVE.

Workstreams should run in parallel. This is not intended to be a sequential one-engineer project.

Acceptance Test

The project is not complete until we can demonstrate:

Provider creates account.
Provider connects hardware.
Reach enrolls endpoint.
Identity is established.
Attestation passes.
Hardware is inventoried.
Hardware is benchmarked.
Provider publishes capacity and ask.
Parinita places a bid.
Provider accepts.
Capacity contract is established.
Capacity enters Denizen Blu capacity systems.
BluRoute selects marketplace capacity.
Beacon resolves the correct compliant runtime endpoint.
Authorized workload reaches the machine.
Workload executes in an isolated runtime.
Host/workload isolation is verified.
Usage is recorded correctly.
Usage is attributable to BluRoute job and contract.
Provider earnings update.
Weekly settlement closes.
Provider generates/accepts settlement invoice.
Ramp payable is created exactly once.
Payment state returns to the provider dashboard.
Quarantined/revoked hardware receives no new jobs.
Cross-tenant access fails.
Failed integrations recover correctly.
Restarts do not lose contracts, usage or settlement state.
Dashboards/alerts are operational.
Runbooks are tested.
Deployment can be reproduced from source.
Production acceptance is signed off.
Required Engineering Level

We are looking for senior, staff, principal-level engineers or a genuinely senior small team.

We are not looking for:

Junior developers
Generic full-stack teams
WordPress/web agencies
Low-code developers
Teams learning distributed systems during this engagement
Agencies whose senior architect sells the engagement and junior engineers perform the work

Because of the September 14 deadline, we expect multiple senior engineers working in parallel.

Ideal experience:

Distributed systems
AI inference infrastructure
GPU clouds
Compute marketplaces
Kubernetes
Linux
Go
Python/FastAPI
PostgreSQL
gRPC
Envoy
Gateway API
Cilium
Containers/containerd
mTLS
SPIFFE/SPIRE
PKI
Ed25519
Device/workload identity
Hardware attestation
NVIDIA CUDA
AMD ROCm
ARM64
Bare-metal provisioning
NATS/Kafka-class messaging
Prometheus
OpenTelemetry
Grafana
GitOps
Software supply-chain security
Ramp APIs/webhooks
Payment/accounting integrations
How to Apply

Begin your response with:

SEPTEMBER 14 — DENIZEN COMPUTE

Then answer every question below.

Can you commit to production completion by September 14, 2026?
How many senior engineers can you allocate immediately?
Who will personally write the production code?
What is the most similar production infrastructure system you have built?
What specifically did you personally implement?
Explain how you would safely execute AI workloads on third-party GPU machines.
How would you isolate the provider's host environment from the Denizen workload?
Explain the difference between BluRoute-style global placement and Beacon-style L7 endpoint selection.
How would you prevent a malicious provider from fabricating GPU utilization?
How would you guarantee economically exactly-once settlement over technically at-least-once event delivery?
Describe your Kubernetes, Cilium/Envoy, mTLS and workload-identity experience.
Describe your GPU runtime experience.
Have you built bare-metal provisioning systems?
Have you integrated Ramp, QuickBooks or comparable payment/AP systems?
What do you see as the three highest technical risks to completing this by September 14?
Provide a proposed staffing plan for September 7–14.
Provide relevant GitHub repositories, architecture samples or production references.

Generic proposals will be rejected.

Engagement Structure

Immediate start.

Milestone and acceptance-test driven.

Daily engineering progress and blocker review.

Source must be committed continuously.

No large "final delivery" dump on September 14.

All production changes require tests.

All P0 failures must be resolved before acceptance.

September 14, 2026 is the production completion and go-live deadline.

Essera Technologies is developing an enterprise AI platform and is seeking an experienced senior full-stack engineer or small development team to build our internal Operations Console.

This is not a simple dashboard or frontend-only project. The Operations Console is a full-stack administrative and operational application with its own application backend, data model, authentication/RBAC, audit trail, workflows, reporting/export capabilities, and integrations with Essera’s existing AI Gateway/backend and AWS infrastructure.

Project Scope

The engagement includes the complete frontend and application-backend implementation of 13 MVP modules:

1. Operations Dashboard — Gateway health, provider/model availability, request volume, latency, usage, spend, estimated revenue/margin, alerts, incidents, compliance items and data-quality/reconciliation status.

2. AI Provider & Model Administration — Provider/model inventory and status, model permissions, approved endpoint/region configuration, timeout/retry/rate-limit settings where applicable, credential administration, connection testing and configuration history.

3. Pricing & Rate Administration — Provider cost rates, customer/partner selling rates, effective-dated pricing, currencies/units, validation, approval, versioning and rollback.

4. Usage, Rating & Billing Data — Request-level usage data, provider cost and billable amounts, detailed filtering and summaries, billing-period workflow, exceptions/adjustments, reconciliation and billing-ready CSV/XLSX exports.

5. Organization, Account & Service Administration — Partner/customer/end-user hierarchy, account status, service/model entitlements, credentials, quotas, spend limits, commercial settings and account history.

6. Compliance & Onboarding Management — Onboarding cases, jurisdiction/use-case information, sanctions/export-control screening records, evidence/document checklists, risk classification, approvals/restrictions and periodic reviews.

7. Platform Monitoring — Gateway, service, provider, database, queue, backup and infrastructure health; throughput/errors; latency; connectivity; and integration with detailed observability resources.

8. Alerts & Incident Management — Alert/incident acknowledgment, assignment, classification, investigation, resolution, evidence, associated resources and action history.

9. Security Administration — Internal administrator management, predefined roles, RBAC, MFA, sessions, account security and privileged activity.

10. Audit & Change Log — Immutable/searchable audit records, before/after values, actor/action/resource information, security/access events and controlled exports.

11. Operational & Business Intelligence — MVP Reduced Scope — Operational and business reporting across customers, partners, providers, models, usage, cost, revenue, gross profit/margin and operating performance. Advanced forecasting, predictive analytics, AI-generated business insights and automated optimization are outside the MVP.

12. Platform Configuration — MVP Lightweight — Global operational settings including timezone, currencies, billing defaults, warning thresholds, notification routing, approved/blocked regions, retention settings, support contacts and Gateway maintenance status.

13. Runbooks & Emergency Resources — MVP Lightweight — Controlled access to approved incident-response, provider-outage, credential-rotation, backup/DR, billing-reconciliation, compliance and emergency resources.

Full-Stack Application Requirements

The selected engineer/team will also implement the shared application foundation, including database schema and migrations; Console backend/API layer; pagination, filtering and validation; defined error/empty states; administrator authentication; MFA and session management; five predefined roles; backend-enforced RBAC; immutable audit/change logging; Gateway/backend API integrations; authorized configuration submission; integration retry/error handling; CSV/XLSX reporting and exports; application observability; containerized AWS deployment; Secrets Manager and CI/CD integration; frontend application shell/design system/navigation; and module-specific workflows and business logic.

The Operations Console is an administrative/control application, not the AI runtime. Real-time AI request routing, provider/model selection, provider execution, runtime retries/fallback, usage capture, metering, rating calculations, reconciliation, quotas/restrictions and real-time policy enforcement remain within Essera’s Gateway/backend. The Console consumes authoritative data and submits authorized administrative configuration.

Required Experience

Strong experience with React/Next.js or comparable frontend frameworks; Python/FastAPI, Node.js/NestJS or comparable backend frameworks; PostgreSQL; REST APIs; RBAC/MFA/session security; multi-tenant SaaS administration; audit logging; data-intensive administrative applications; reporting/CSV/XLSX exports; AWS/ECS/Fargate; Secrets Manager; CI/CD; and CloudWatch/Grafana/OpenTelemetry or similar observability tools.

Experience with enterprise AI platforms, Amazon Bedrock, LLM gateways, usage metering, FinOps/billing systems or compliance platforms is highly desirable.

Detailed functional requirements and interface documentation will be provided to the selected engineer/team. Applicants should provide relevant examples of full-stack SaaS or operations-console projects, backend/API architecture experience, authentication/RBAC/audit experience, AWS experience, proposed team composition, expected delivery schedule, and any key assumptions or dependencies.

Acceptance is based on working full-stack functionality, not screens alone. Required outputs must reconcile to authoritative backend data; controls must be role-restricted and auditable; required validation, error/empty states and exports must function; and the defined Console/Gateway/backend responsibility boundary must be maintained.

Essera Technologies is developing an enterprise AI platform and is seeking an experienced senior full-stack engineer or small development team to build our internal Operations Console.

This is not a simple dashboard or frontend-only project. The Operations Console is a full-stack administrative and operational application with its own application backend, data model, authentication/RBAC, audit trail, workflows, reporting/export capabilities, and integrations with Essera’s existing AI Gateway/backend and AWS infrastructure.

Project Scope

The engagement includes the complete frontend and application-backend implementation of 13 MVP modules:

1. Operations Dashboard — Gateway health, provider/model availability, request volume, latency, usage, spend, estimated revenue/margin, alerts, incidents, compliance items and data-quality/reconciliation status.

2. AI Provider & Model Administration — Provider/model inventory and status, model permissions, approved endpoint/region configuration, timeout/retry/rate-limit settings where applicable, credential administration, connection testing and configuration history.

3. Pricing & Rate Administration — Provider cost rates, customer/partner selling rates, effective-dated pricing, currencies/units, validation, approval, versioning and rollback.

4. Usage, Rating & Billing Data — Request-level usage data, provider cost and billable amounts, detailed filtering and summaries, billing-period workflow, exceptions/adjustments, reconciliation and billing-ready CSV/XLSX exports.

5. Organization, Account & Service Administration — Partner/customer/end-user hierarchy, account status, service/model entitlements, credentials, quotas, spend limits, commercial settings and account history.

6. Compliance & Onboarding Management — Onboarding cases, jurisdiction/use-case information, sanctions/export-control screening records, evidence/document checklists, risk classification, approvals/restrictions and periodic reviews.

7. Platform Monitoring — Gateway, service, provider, database, queue, backup and infrastructure health; throughput/errors; latency; connectivity; and integration with detailed observability resources.

8. Alerts & Incident Management — Alert/incident acknowledgment, assignment, classification, investigation, resolution, evidence, associated resources and action history.

9. Security Administration — Internal administrator management, predefined roles, RBAC, MFA, sessions, account security and privileged activity.

10. Audit & Change Log — Immutable/searchable audit records, before/after values, actor/action/resource information, security/access events and controlled exports.

11. Operational & Business Intelligence — MVP Reduced Scope — Operational and business reporting across customers, partners, providers, models, usage, cost, revenue, gross profit/margin and operating performance. Advanced forecasting, predictive analytics, AI-generated business insights and automated optimization are outside the MVP.

12. Platform Configuration — MVP Lightweight — Global operational settings including timezone, currencies, billing defaults, warning thresholds, notification routing, approved/blocked regions, retention settings, support contacts and Gateway maintenance status.

13. Runbooks & Emergency Resources — MVP Lightweight — Controlled access to approved incident-response, provider-outage, credential-rotation, backup/DR, billing-reconciliation, compliance and emergency resources.

Full-Stack Application Requirements

The selected engineer/team will also implement the shared application foundation, including database schema and migrations; Console backend/API layer; pagination, filtering and validation; defined error/empty states; administrator authentication; MFA and session management; five predefined roles; backend-enforced RBAC; immutable audit/change logging; Gateway/backend API integrations; authorized configuration submission; integration retry/error handling; CSV/XLSX reporting and exports; application observability; containerized AWS deployment; Secrets Manager and CI/CD integration; frontend application shell/design system/navigation; and module-specific workflows and business logic.

The Operations Console is an administrative/control application, not the AI runtime. Real-time AI request routing, provider/model selection, provider execution, runtime retries/fallback, usage capture, metering, rating calculations, reconciliation, quotas/restrictions and real-time policy enforcement remain within Essera’s Gateway/backend. The Console consumes authoritative data and submits authorized administrative configuration.

Required Experience

Strong experience with React/Next.js or comparable frontend frameworks; Python/FastAPI, Node.js/NestJS or comparable backend frameworks; PostgreSQL; REST APIs; RBAC/MFA/session security; multi-tenant SaaS administration; audit logging; data-intensive administrative applications; reporting/CSV/XLSX exports; AWS/ECS/Fargate; Secrets Manager; CI/CD; and CloudWatch/Grafana/OpenTelemetry or similar observability tools.

Experience with enterprise AI platforms, Amazon Bedrock, LLM gateways, usage metering, FinOps/billing systems or compliance platforms is highly desirable.

Contract: Fixed Price
Total Budget: $12,000
Scope: Complete frontend + application backend across all 13 MVP modules

Detailed functional requirements and interface documentation will be provided to the selected engineer/team. Applicants should provide relevant examples of full-stack SaaS or operations-console projects, backend/API architecture experience, authentication/RBAC/audit experience, AWS experience, proposed team composition, expected delivery schedule, and any key assumptions or dependencies.

Acceptance is based on working full-stack functionality, not screens alone. Required outputs must reconcile to authoritative backend data; controls must be role-restricted and auditable; required validation, error/empty states and exports must function; and the defined Console/Gateway/backend responsibility boundary must be maintained.

We are looking for a Senior Database Engineer to take ownership of our existing database environment, understand the current setup, and improve it over time.

The role also includes building and maintaining Grafana dashboards for operational and management reporting.

Responsibilities

-Understand and document the existing database structure, tables, relationships, and data flows.
-Improve database architecture, performance, scalability, and maintainability.
-Optimize SQL queries, indexes, views, and stored processes.
-Identify inefficient, duplicated, or inconsistent database structures.
-Support developers with database design for new features.
-Troubleshoot database issues and performance bottlenecks.
-Create reporting datasets and SQL views.
-Build and maintain Grafana dashboards, KPIs, filters, and visualizations.
-Improve database monitoring, data quality, backup, and reliability processes.

Requirements

-Senior-level experience with relational databases.
-Strong SQL skills.
-Strong experience with MySQL / MariaDB or similar databases.
-Experience with query optimization, indexing, and performance analysis.
-Ability to understand and improve an existing database environment.
-Experience with Grafana and SQL-based reporting.
-Good understanding of database architecture, data integrity, and scalability.
-Ability to work independently and take ownership.

# Senior Hyperledger Besu / Blockchain Security Engineer — Chrysalis Production Build by Monday

## URGENT — HARD DEADLINE: MONDAY, SEPTEMBER 7, 2026

We are looking for a senior hands-on **Hyperledger Besu / EVM / distributed-systems security engineer** to productionize **Chrysalis**, our blockchain-backed evidence, provenance, attestation, and verifiable transaction-record infrastructure for AI agents and autonomous systems.

This is an immediate-start engineering sprint.

**You must be able to start immediately and work through the weekend as necessary to reach the Monday production gate.**

Chrysalis already exists as part of our broader AI security architecture.

This is **not a greenfield blockchain experiment**, token project, cryptocurrency product, or DeFi application.

Chrysalis uses **Hyperledger Besu as a permissioned blockchain/evidence layer** to provide durable, cryptographically verifiable records of agent actions, authorization, policy decisions, tool execution, MCP activity, and security events.

We need an engineer who can work directly in the existing codebase and Besu environment, identify production gaps, complete the implementation, harden the network, validate consensus and evidence integrity, and deliver a working production deployment by Monday.

# What Chrysalis Does

AI agents increasingly:

* Invoke tools
* Call MCP servers
* Access enterprise systems
* Exercise delegated authority
* Execute workflows
* Make decisions
* Act on behalf of humans and organizations

Traditional logs alone are insufficient to establish an independently verifiable history of these actions.

Chrysalis creates a verifiable evidence chain around them.

It should allow an authorized party to establish:

* Who initiated an action
* Which identity was involved
* Which agent acted
* Under whose authority
* Which authorization was issued
* Which policy was evaluated
* What constraints applied
* What MCP server or tool was called
* What execution occurred
* What result was returned
* When it occurred
* Whether the historical evidence has subsequently been changed

The blockchain is therefore not the application itself.

**Hyperledger Besu provides the trust and integrity foundation for Chrysalis evidence.**

# Technology Direction

The production architecture is based on:

* **Hyperledger Besu**
* Permissioned EVM network
* Enterprise/private blockchain architecture
* Cryptographically signed evidence
* Transaction receipts
* Smart contracts where appropriate
* Durable off-chain evidence where appropriate
* On-chain hashes/commitments
* Merkle structures where appropriate
* Enterprise identity and authorization
* Production Kubernetes infrastructure

The engineer should be able to make sensible decisions regarding which evidence belongs directly on-chain and which should remain off-chain with cryptographic commitments anchored to Besu.

We do **not** want large confidential payloads placed unnecessarily on-chain.

# Monday Production Objective

By Monday, we need a working production-capable Chrysalis path demonstrating:

**Agent action
→ identity and authorization context
→ Chrysalis evidence creation
→ evidence hash / commitment
→ Hyperledger Besu transaction
→ confirmed ledger record
→ transaction/evidence receipt
→ evidence retrieval
→ independent verification.**

The production gate must use the actual Besu network.

Mocked blockchain calls do not satisfy the requirement.

# Hyperledger Besu Requirements

The selected engineer must review and productionize the existing Besu implementation.

Responsibilities may include:

* Besu node deployment
* Genesis configuration
* Network configuration
* Permissioning
* Validator configuration
* Consensus configuration
* Peer discovery
* Bootnodes
* RPC configuration
* TLS
* Node keys
* Account management
* Smart-contract deployment
* Contract upgrades where applicable
* Transaction submission
* Transaction monitoring
* Receipt generation
* Block confirmation
* Failure handling
* Network recovery
* Node replacement
* Chain persistence
* Monitoring
* Backup/recovery
* Kubernetes deployment

# Consensus and Validator Layer

The engineer must review the current consensus implementation and ensure it is appropriate for the Chrysalis production architecture.

This includes validation of:

* Validator membership
* Validator keys
* Quorum assumptions
* Block production
* Consensus failure behavior
* Validator loss
* Network partition behavior
* Node resynchronization
* Validator addition/removal
* Genesis and chain configuration
* Production key custody

If the existing Chrysalis architecture uses **QBFT**, the engineer must be comfortable operating and troubleshooting Besu QBFT in production.

The engineer should not arbitrarily change the consensus model without reviewing the existing architecture and requirements.

# Evidence Architecture

Chrysalis should maintain structured evidence associated with actions such as:

* Human authorization
* Agent authorization
* Delegated authority
* Policy evaluation
* MCP invocation
* Tool execution
* API execution
* Resource access
* Security decision
* Execution result
* Denied action
* Failed action

Evidence records should support appropriate fields including:

* Evidence ID
* Event ID
* Timestamp
* Tenant
* Principal
* Principal type
* Agent identity
* Session/execution ID
* Delegating principal
* Action
* Resource
* MCP server
* Tool
* Authorization reference
* Approval reference
* Policy
* Policy version
* Constraints
* Input digest
* Output/result digest
* Correlation ID
* Trace ID
* Blockchain network
* Chain ID
* Smart-contract address
* Transaction hash
* Block number
* Block hash
* Evidence hash
* Signature
* Key ID
* Schema version
* Execution status

The engineer should reconcile this with the existing Chrysalis schema rather than unnecessarily redesigning the platform.

# On-Chain vs. Off-Chain Evidence

The engineer must design or validate a production-safe pattern for evidence storage.

We expect a model such as:

### Off-chain

Potentially sensitive or high-volume evidence can remain in controlled durable storage.

Examples:

* Full request payloads
* Full response payloads
* Sensitive business data
* Large execution artifacts
* Detailed traces

### On-chain

Besu can preserve the cryptographic proof necessary to verify the evidence.

Examples:

* Evidence hash
* Merkle root
* Evidence ID
* Timestamp/reference
* Authorization reference
* Principal/agent reference where appropriate
* Event type
* Schema/version
* Signature reference
* Evidence commitment
* Previous commitment where required

The final design must preserve integrity without unnecessarily exposing confidential information on the ledger.

# Smart Contracts

The engineer should review and complete the Chrysalis contract layer.

Potential contract responsibilities may include:

* Evidence anchoring
* Evidence registration
* Receipt references
* Evidence-root commitments
* Identity references
* Authorization references
* Evidence versioning
* Verification metadata
* Revocation/status events where applicable

Contracts must be:

* Version controlled
* Tested
* Deterministic
* Gas-aware
* Upgrade strategy documented
* Access controlled
* Protected from unauthorized evidence submission
* Designed for a permissioned network

This is not a public-token contract project.

# Receipt Generation

Every relevant evidence submission should produce a machine-verifiable Chrysalis receipt.

A receipt should be capable of referencing:

* Chrysalis evidence ID
* Evidence digest
* Transaction hash
* Block number
* Block hash
* Chain ID
* Contract address
* Event/log index where applicable
* Signer
* Signing key ID
* Timestamp
* Schema/version
* Verification information

The receipt should allow another authorized system to independently determine whether the associated evidence is represented on the Chrysalis ledger.

# Verification Service

Chrysalis needs a verification path.

Given an evidence record or receipt, the verifier should be able to establish:

1. Is the receipt structurally valid?
2. Is the digital signature valid?
3. Does the referenced Besu transaction exist?
4. Is it on the expected chain?
5. Was it committed to a valid block?
6. Does the expected smart-contract event exist?
7. Does the stored evidence digest match the on-chain commitment?
8. Has the off-chain evidence been altered?
9. Is the evidence associated with the expected identity/authorization context?
10. Is the schema/version understood?

Verification failures must fail explicitly.

# Witness / Secure / Sentry Integration

Chrysalis forms an evidence layer for our broader security architecture.

It must support evidence originating from systems including:

* **Witness** — authorization and approval
* **Secure** — security/posture controls
* **Sentry** — MCP security/gateway activity

Chrysalis does not need to rebuild these systems.

Instead, it needs stable typed interfaces for ingesting their security evidence.

Examples include:

**Witness decision
→ Chrysalis evidence object
→ evidence commitment
→ Besu transaction
→ Chrysalis receipt**

and:

**MCP request through Sentry
→ policy/security decision
→ tool invocation
→ execution result
→ Chrysalis evidence
→ Besu transaction
→ verifiable receipt**

# Authorization Evidence

A major requirement is proving not merely that an AI agent performed an action, but that it possessed the appropriate authority.

Where available, Chrysalis should capture or reference:

* Principal
* Agent
* Delegating principal
* Authorization ID
* Approval
* Scope
* Resource
* Constraints
* Policy
* Policy version
* Expiration
* Decision
* Decision timestamp
* Execution timestamp
* Result

A missing approval or authorization record must never silently become a valid authorization record.

# Key Management

Production signing and validator keys must be handled securely.

The engineer should review:

* Besu node keys
* Validator keys
* Application signing keys
* Transaction signing
* Smart-contract administrative keys
* Key rotation
* Backup/recovery
* Compromise handling
* Separation of duties

Keys must not be hardcoded into:

* Source code
* Docker images
* Helm charts
* Kubernetes manifests
* CI/CD configuration
* Git repositories

The architecture should be compatible with hardware-backed or enterprise key management.

Experience with **HSMs, PKCS#11, Vault, cloud KMS, or equivalent enterprise key management** is highly valuable.

# Permissioning

Chrysalis is a controlled enterprise blockchain.

The engineer must implement or validate:

* Node permissioning
* Account permissioning where required
* RPC access restrictions
* Validator controls
* Administrative access
* Network-level access
* Service authentication
* Tenant authorization
* Contract authorization

We do not want an unrestricted public Ethereum-style RPC endpoint exposed to the Internet.

# Failure Testing

The Monday implementation must include actual failure testing.

Examples:

* Stop one Besu node.
* Restart a Besu node.
* Lose a validator.
* Recover a validator.
* Restart Chrysalis.
* Submit duplicate evidence.
* Submit malformed evidence.
* Submit unauthorized evidence.
* Submit evidence during partial node failure.
* Verify a valid transaction.
* Verify a nonexistent transaction.
* Modify off-chain evidence and demonstrate hash mismatch.
* Attempt cross-tenant retrieval.
* Redeploy the application while preserving blockchain state.

# Observability

We must be able to operate the Besu network.

Required visibility should include, where appropriate:

* Node health
* Peer count
* Validator status
* Current block
* Block production
* Block interval
* Transaction pool
* Transactions submitted
* Transactions confirmed
* Failed transactions
* RPC latency
* Consensus problems
* Peer connectivity
* Evidence submissions
* Evidence confirmation latency
* Verification requests
* Verification failures
* Smart-contract errors
* Storage errors
* API errors

Prometheus/Grafana and OpenTelemetry experience is valuable.

# Day 1 — Architecture and Besu Audit

Immediately:

* Build and run Chrysalis.
* Review the existing Besu network.
* Review genesis configuration.
* Review consensus.
* Review validators.
* Review permissioning.
* Review smart contracts.
* Review evidence schema.
* Review transaction submission.
* Review receipts.
* Review verification.
* Review storage.
* Review keys.
* Identify mocked/in-memory/test-only components.
* Identify production blockers.

Then begin fixing them immediately.

We expect working code on Day 1.

# Day 2 — Besu and Evidence Core

Complete or harden:

* Besu deployment
* Validators
* Consensus
* Permissioning
* Contract deployment
* Evidence schema
* Evidence hashing
* On-chain commitment
* Transaction submission
* Transaction confirmation
* Receipt generation
* Off-chain persistence
* Verification

# Day 3 — Security, Integration and Failure Testing

Complete:

* Witness/Secure/Sentry evidence interface
* Authentication
* Authorization
* Tenant isolation
* Key-management integration
* Duplicate/replay protection
* Tamper testing
* Node-failure testing
* Validator-failure testing
* Transaction-failure testing
* Evidence-verification tests
* Monitoring
* Metrics
* Logging
* Deployment automation

# Monday — Production Gate

Before acceptance, demonstrate:

1. Production Chrysalis service running.
2. Production Besu network running.
3. Validators healthy.
4. Consensus operating.
5. Permissioning enabled.
6. Chrysalis evidence submitted.
7. Evidence anchored to Besu.
8. Transaction confirmed.
9. Blockchain receipt generated.
10. Evidence retrieved.
11. Evidence independently verified.
12. Off-chain evidence modified.
13. Modification detected.
14. Invalid receipt rejected.
15. Unauthorized evidence submission rejected.
16. Besu node restarted successfully.
17. Validator failure scenario tested.
18. Chrysalis restarted without losing evidence.
19. Redeployment does not destroy ledger state.
20. Monitoring operational.

# Monday Definition of Done

The production gate is:

**Agent/security event
→ Chrysalis
→ evidence digest
→ authenticated Besu transaction
→ consensus
→ committed block
→ verifiable blockchain receipt
→ evidence retrieval
→ cryptographic verification.**

And separately:

**Stored evidence altered
→ digest no longer matches on-chain commitment
→ verification fails.**

A design document, architecture diagram, smart-contract prototype, local single-node Besu demo, or PowerPoint does not satisfy this requirement.

We need working production software.

# Required Experience

Strong hands-on experience with several of:

* Hyperledger Besu
* Ethereum / EVM
* Solidity
* Permissioned blockchain
* QBFT / BFT consensus
* Distributed systems
* Blockchain node operation
* Smart contracts
* Blockchain RPC
* Transaction lifecycle
* Cryptography
* PKI
* Digital signatures
* Merkle trees
* Security engineering
* Go / Java / Rust / TypeScript
* Kubernetes
* Docker
* PostgreSQL
* Object storage
* CI/CD
* Prometheus/Grafana
* Enterprise key management

# Strongly Preferred

Particularly valuable:

* Production Hyperledger Besu deployments
* Besu QBFT
* Multi-validator networks
* Besu Kubernetes deployments
* HSM integration
* PKCS#11
* Enterprise blockchain
* Permissioning
* Smart-contract security
* Zero Trust
* SPIFFE/SPIRE
* AI agent infrastructure
* Model Context Protocol
* High-throughput event systems
* Evidence/provenance platforms

# We Are NOT Looking For

Do not apply if your blockchain experience is primarily:

* Cryptocurrency trading
* NFTs
* Meme coins
* Token launches
* DeFi frontend development
* Wallet UI development
* Public-chain tutorials
* Smart-contract boot camps
* Blockchain architecture presentations without operating production networks

We need someone who has actually built and operated distributed blockchain infrastructure.

# Application Questions

## 1. Monday Commitment

Can you start immediately and work through Monday, September 7, 2026?

State the exact number of hours you can personally commit before the production gate.

## 2. Hyperledger Besu

Describe the largest Hyperledger Besu network you have personally deployed.

Include:

* Number of nodes
* Number of validators
* Consensus mechanism
* Deployment environment
* Your personal responsibilities

## 3. QBFT

What production experience do you have with QBFT or another Byzantine fault-tolerant consensus protocol?

## 4. Besu Failure Scenario

A four-validator Besu network stops finalizing blocks.

Walk us through exactly how you diagnose it.

## 5. Evidence Architecture

An AI agent performs an action under delegated human authorization.

Describe what you would:

* Store off-chain
* Hash
* Put on-chain
* Sign
* Return in the Chrysalis receipt

## 6. Smart Contracts

Describe a production Solidity/EVM contract system you personally implemented or audited.

## 7. Tampering

Someone modifies the off-chain evidence six months after the event.

How does Chrysalis prove that the evidence no longer matches the original transaction?

## 8. Key Security

How would you protect:

* Validator keys
* Transaction signing keys
* Contract administrative keys?

## 9. Besu on Kubernetes

Describe how you would deploy a persistent multi-validator Besu network on Kubernetes without risking chain loss during routine deployment.

## 10. Start Time

What exact time can you begin?

# IMPORTANT APPLICATION INSTRUCTION

Begin your proposal with:

**CHRYSALIS BESU MONDAY**

Then write:

**Available engineering hours before Monday: XX**

Applications without these two lines will not be prioritized.

# Engagement

This is initially a high-intensity sprint culminating in the Monday production gate.

Strong engineers may continue into the subsequent Chrysalis work, including:

* HSM-backed validator/signing infrastructure
* Advanced key custody
* Multi-region Besu
* Additional validators
* Disaster recovery
* Evidence replication
* High-throughput evidence batching
* Merkle-root anchoring
* Advanced receipt verification
* AI agent provenance
* MCP provenance
* Policy evidence
* Compliance evidence
* External verification
* Security analytics
* Large-scale production hardening

The immediate requirement is straightforward:

**By Monday, Chrysalis must be operating on Hyperledger Besu and producing durable, verifiable blockchain-backed evidence of AI-agent and security actions.**

# Senior Kubernetes / MCP Platform Engineer — Tapestry Production Deployment by Monday

## URGENT — HARD DEADLINE: MONDAY, SEPTEMBER 7, 2026

We need a senior hands-on Kubernetes / Platform Engineer to take our existing **Tapestry MCP platform** and complete its initial production deployment **by Monday, September 7, 2026**.

This is an immediate-start, high-intensity deployment sprint.

**Do not apply unless you can start immediately and work through the weekend as necessary to meet the Monday production gate.**

Tapestry is already being developed. We are **not hiring someone to design an MCP platform from scratch**. The objective is to take the existing implementation, understand it rapidly, resolve deployment blockers, automate the deployment, and get a production instance running and validated.

## Monday Production Gate

By Monday, we need:

* Tapestry successfully deployed to the target Kubernetes environment.
* Required Tapestry services running as containers.
* Kubernetes manifests / Helm configuration committed to source control.
* Environment configuration separated from application code.
* Production secrets handled securely.
* Internal and external networking configured as required.
* DNS/TLS configured where required.
* MCP endpoint connectivity validated end-to-end.
* Health/readiness/liveness checks operational.
* Services able to restart and recover from ordinary failures.
* Centralized logging available.
* Core metrics available.
* Basic monitoring/alerting configured.
* CI/CD or a repeatable automated deployment process operational.
* Fresh deployment procedure validated.
* Upgrade/redeployment procedure validated.
* Basic rollback capability demonstrated.
* Deployment documentation completed sufficiently for our team to reproduce the deployment.

The deployment **cannot depend on undocumented manual steps known only to the engineer**.

## Immediate Sprint

### Day 1 — Architecture & Deployment Assessment

Immediately upon access:

* Review Tapestry repositories.
* Run the existing application.
* Identify all services and dependencies.
* Map ports, endpoints, storage, databases, queues, credentials, and external services.
* Review existing Docker/Kubernetes artifacts.
* Identify production blockers.
* Establish the deployment architecture.
* Create a prioritized blocker list.
* Begin deployment immediately rather than spending the entire day producing documentation.

We expect working code and deployment artifacts on Day 1.

### Day 2 — Kubernetes Deployment

Build or complete:

* OCI/Docker images
* Kubernetes Deployments
* Services
* Namespaces
* ConfigMaps
* Secrets integration
* Ingress/routing
* TLS
* DNS integration
* Service accounts
* RBAC
* Network policies
* Resource requests/limits
* Health probes
* Persistent storage configuration where required

Helm is preferred for the production deployment unless there is a strong technical reason to use another approach.

The deployment must be parameterized so that it can later be repeated across multiple Tapestry locations.

### Day 3 — Automation, MCP Validation & Observability

Complete:

* Automated deployment
* Build pipeline
* Image publishing
* Environment configuration
* Deployment pipeline
* MCP endpoint testing
* Client-to-Tapestry connectivity validation
* Authentication validation
* Logging
* Metrics
* Basic dashboards
* Basic alerts
* Restart/recovery testing

Test actual MCP calls rather than merely confirming that TCP ports are open.

### Day 4 / Monday — Production Gate

Before final acceptance:

* Deploy into a clean or controlled target environment.
* Validate the complete deployment procedure.
* Run MCP connectivity tests.
* Validate service recovery.
* Test redeployment.
* Test rollback.
* Resolve Priority 0 deployment defects.
* Review monitoring.
* Deliver deployment documentation.
* Conduct engineering handoff.
* Produce a list of post-gate hardening work, if any.

**Monday means operational deployment, not delivery of a design document or recommendations for how we could deploy it later.**

## Multi-Site Requirement

Tapestry is intended to operate across distributed infrastructure.

The deployment therefore must not be tightly coupled to one Kubernetes cluster.

Site-specific values should be configurable, including:

* Site ID
* Cluster ID
* Environment
* Domain
* MCP endpoints
* Networking
* Resource allocations
* Storage
* Credentials
* Observability configuration
* Authentication
* Enabled services
* External integrations

Our objective is to make subsequent Tapestry deployments configuration-driven rather than separate engineering projects.

## MCP Requirements

Experience with Model Context Protocol is strongly preferred.

You should understand or be able to become productive immediately with:

* MCP servers
* MCP clients
* Tools
* Resources
* MCP transports
* Sessions
* Authentication
* Tool invocation
* Connection lifecycle
* MCP endpoint testing
* Error handling
* Compatibility/versioning

Experience deploying AI agent infrastructure, API gateways, distributed tool-execution systems, or LLM infrastructure is also relevant.

## Security

The initial production deployment must address:

* Least privilege
* Kubernetes RBAC
* Service accounts
* Namespace isolation
* Secrets management
* TLS
* Network policies
* Secure CI/CD credentials
* Image vulnerability management
* Administrative access
* Logging/auditability

Production credentials must not be hardcoded into:

* Source code
* Dockerfiles
* Kubernetes manifests
* Helm charts
* Git repositories
* CI/CD definitions

## Required Skills

Expert-level hands-on experience with several of:

* Kubernetes
* Helm
* Docker / OCI
* Linux
* CI/CD
* GitHub Actions / GitLab CI or equivalent
* GitOps
* Argo CD / Flux
* Terraform
* Networking
* DNS
* TLS / PKI
* Secrets management
* Observability
* OpenTelemetry
* Prometheus
* Grafana
* Distributed systems
* High-availability services
* API infrastructure
* AI infrastructure

## Particularly Valuable

* Model Context Protocol
* AI agents
* MCP gateways
* LLM infrastructure
* Multi-cluster Kubernetes
* Edge infrastructure
* GPU/AI infrastructure
* Zero-trust networking
* Service mesh
* Large-scale SaaS/platform operations

## Deliverables

All deliverables must be committed to our designated repositories.

1. Production Tapestry Kubernetes deployment
2. Helm chart and/or approved equivalent
3. Container build definitions
4. Environment configuration
5. Secrets integration
6. Networking configuration
7. TLS configuration
8. Deployment automation
9. CI/CD pipeline
10. Logging
11. Metrics
12. Basic operational dashboard
13. Alerts for critical failures
14. MCP deployment validation tests
15. Restart/recovery validation
16. Rollback mechanism
17. Deployment documentation
18. Troubleshooting/runbook documentation
19. Monday engineering handoff
20. Post-deployment hardening backlog

## Definition of Done

The Monday milestone is achieved when our team can demonstrate:

**Clean environment → automated deployment → healthy Tapestry services → working MCP connection → successful MCP invocation → observable transaction → service recovery test → successful redeployment/rollback.**

A PowerPoint, architecture diagram, assessment, or list of recommendations does **not** constitute completion.

## Availability

This is an urgent engagement.

You must be:

* Available to start immediately.
* Available Friday.
* Available Saturday.
* Available Sunday.
* Available Monday through the production gate.
* Able to communicate frequently with our engineering team.
* Able to commit meaningful engineering hours during the four-day sprint.

Please state the **actual number of hours you can personally commit between now and Monday**.

Do not apply if you need several days before beginning.

## Application Questions

Please answer every question.

### 1. Monday Commitment

Can you personally commit to having the production deployment working by **Monday, September 7, 2026**?

How many hours can you commit between now and Monday?

### 2. Kubernetes

Describe the most complicated production Kubernetes platform you personally deployed.

What did *you* implement?

### 3. Emergency Deployment

Describe a time you had to productionize or recover a platform under a very short deadline.

What was the situation and what did you deliver?

### 4. MCP

Have you deployed MCP servers or MCP infrastructure?

If yes, describe it.

If not, describe your closest production experience with agent infrastructure, API gateways, distributed services, or AI platforms.

### 5. Helm

Show or describe a production Helm deployment you have built.

### 6. Observability

What are the first metrics, logs, traces, and alerts you would implement for Tapestry?

### 7. Failure Scenario

An MCP service begins repeatedly restarting 20 minutes after deployment.

Walk us through exactly how you diagnose it.

### 8. Rollback

How would you design Monday's deployment so we can safely revert a bad release?

### 9. Start

What exact time can you begin?

## IMPORTANT APPLICATION INSTRUCTION

Start your proposal with:

**TAPESTRY MONDAY**

Then provide:

**Available hours before Monday: XX**

Applications that do not include both will not be prioritized.

## Engagement Structure

This initial engagement is a **four-day production sprint** culminating in the Monday production gate.

Successful engineers may be retained for the subsequent phase, which will include:

* Hardening
* Automated multi-site rollout
* Fleet operations
* Scaling
* Advanced observability
* Security improvements
* Performance engineering
* Disaster recovery
* Additional Tapestry deployments

We are looking for someone capable of becoming a core implementation resource, but **the immediate objective is simple: Tapestry must be deployed and working by Monday.**

I have developed an anomaly-detection methodology for production observability data and am looking for an experienced SRE/observability engineer to independently evaluate it.

The ideal candidate currently works with, or has legitimate authorized access to, a real production environment generating meaningful telemetry (metrics/logs/traces). Mandatory: US based or working US based company.

The engagement involves applying my methodology to an appropriate production dataset, comparing the detected anomalies with known incidents/operational events where possible, documenting the results, and providing a short written technical attestation describing the methodology followed and observed results.

Requirements: 5+ years SRE/DevOps/production operations experience; hands-on observability experience; experience with tools such as Datadog, Grafana/Prometheus, Dynatrace, New Relic, Splunk, Elastic, etc.; ability to work with production telemetry with appropriate authorization and confidentiality; willingness to document methodology and results.

No proprietary production data needs to be shared with me if company policy prohibits it; sanitized/aggregated results are acceptable.

We need a freelancer to build and maintain Grafana dashboards for observability and monitoring. You will create clear, actionable dashboards, connect data sources, and help improve visibility into system performance. This is a long-term project for someone who can work independently, communicate clearly, and support ongoing dashboard development. If you have experience with observability workflows and can deliver reliable monitoring solutions, we’d like to hear from you.

We are looking for an experienced full-stack developer to build and maintain a production-ready B2B digital top-up platform.

The platform consists of a secure REST API used by client accounts and a responsive administration dashboard for managing users, wallets, and mobile top-up transactions. The developer should be comfortable owning backend architecture, frontend integration, testing, and deployment.

Key responsibilities include:

- Develop a modular NestJS and TypeScript backend using vertical-slice and CQRS patterns.
- Implement JWT authentication, refresh tokens, role-based authorization, API-key authentication, and rate limiting.
- Build client-account and user-management functionality.
- Implement wallets with available and reserved balances, deposits, transaction reservations, and an auditable ledger.
- Manage digital products and configurable top-up offers.
- Build the mobile top-up workflow, including amount and phone-number validation, external transaction IDs, duplicate prevention, balance checks, and status lookup.
- Implement reliable asynchronous provider processing using Redis, BullMQ, retries, recovery jobs, and the transactional outbox pattern.
- Provide consistent API error responses, Swagger documentation, pagination, filtering, and sorting.
- Develop a responsive React administration dashboard for authentication, user and wallet visibility, and transaction monitoring.
- Add transaction and user search, filters, pagination, status indicators, and copy-to-clipboard utilities.
- Write unit, integration, and browser-based tests.
- Configure PostgreSQL migrations, Docker images, CI pipelines, health checks, CORS, and structured logging.
- Deploy the API and dashboard to an Ubuntu VPS using Docker and Dokploy, with Ansible-based provisioning and production observability.

The frontend technology stack includes React, TypeScript, Vite, TanStack Router, TanStack Query, Tailwind CSS, shadcn/ui, Zustand, Axios, Zod, Vitest, and Playwright.

The backend technology stack includes NestJS, TypeScript, PostgreSQL, TypeORM, Redis, BullMQ, JWT, Swagger/OpenAPI, Jest, Docker, GitHub Actions, Ansible, Dokploy, Pino, and Grafana/Loki.

Expected deliverables:

- Production-ready backend API and administration dashboard.
- Database schema and migrations.
- Secure authentication and authorization.
- Reliable wallet and top-up transaction processing.
- Automated tests and CI checks.
- API documentation and example HTTP requests.
- Dockerized deployment with environment and operations documentation.
- Clean, maintainable source code suitable for future integrations and ongoing development.

The ideal candidate has strong experience with transactional systems, REST API design, PostgreSQL consistency, asynchronous job processing, React administration interfaces, and end-to-end production deployment. Experience with fintech, payment, telecom, wallet, or digital-product platforms is highly desirable.

This may begin as a defined project and continue into ongoing maintenance, provider integrations, dashboard enhancements, and operational support.


----------------------------------------
Suggested Upwork skills: TypeScript, NestJS, Node.js, React, PostgreSQL, Redis, REST API, Docker, TypeORM, Tailwind CSS, DevOps, and Full-Stack Development.