Boost Grafana Projects with Vollna's Tools

Looking for an experienced cloud instructor to teach 1:1 about cloud and DevOps. 20 hours weekly if given a good deal package.

About Us

We are a rapidly growing telecommunications technology company building APIs and cloud-based communications solutions for businesses around the world. Our platform includes multiple products, applications, APIs, and customer-facing tools, and we're looking for someone who is passionate about quality and enjoys solving technical problems.

Position Overview

We're looking for a QA Engineer / Junior Software Developer to help ensure our products are reliable, stable, and ready for production.

This is more than a traditional QA position. We're looking for someone who enjoys digging into problems, understanding how systems work, and helping engineers identify the root cause of issues rather than simply reporting that something is broken.

You'll work across multiple products, APIs, web applications, and internal systems. The ideal candidate is detail-oriented, technically curious, and comfortable working closely with developers to investigate bugs, validate new features, and improve the overall quality of the platform.

This is an excellent opportunity for someone who wants to grow into a software engineering role while gaining hands-on experience working with APIs, cloud infrastructure, and modern SaaS applications.

Responsibilities
Perform quality assurance across multiple products and business units.
Test new features before release and perform regression testing on existing functionality.
Validate REST APIs using tools such as Postman, Insomnia, cURL, or similar.
Test API requests, authentication, JSON payloads, webhooks, error handling, and edge cases.
Verify functionality across web applications, customer portals, dashboards, and backend services.
Reproduce customer-reported issues and document clear reproduction steps.
Investigate bugs to determine whether they originate from the frontend, backend, API layer, third-party integrations, configuration, or data.
Create detailed bug reports with screenshots, logs, request payloads, and supporting information.
Verify bug fixes after deployment.
Assist with release testing and production validation.
Maintain QA documentation, test plans, and regression checklists.
Work closely with engineering and product teams throughout the development lifecycle.
Assist with light development work, scripting, or internal tooling as your technical skills grow.
Required Qualifications
1+ years of experience in QA, software development, technical support, or another technical role.
Experience testing REST APIs.
Familiarity with Postman, Insomnia, cURL, or similar API testing tools.
Understanding of HTTP methods, JSON, authentication, headers, status codes, and webhooks.
Strong analytical and troubleshooting skills.
Excellent attention to detail.
Ability to clearly document technical issues.
Comfortable learning new technologies in a fast-paced environment.
Preferred Qualifications
Experience with JavaScript, TypeScript, Python, PHP, or another programming language.
Familiarity with Git.
Basic SQL knowledge.
Experience with SaaS platforms.
Experience testing APIs and cloud applications.
Experience reading logs and debugging distributed systems.
Familiarity with monitoring tools such as Datadog, Grafana, CloudWatch, or similar.
Experience with automated testing frameworks is a plus.
Experience in telecommunications, messaging, voice, or API platforms is a plus.
What Makes Someone Successful in This Role

We're looking for someone who naturally asks "why?"

When something doesn't work, you don't stop after identifying the bug. You want to understand why it happened, how to reproduce it consistently, and what information the engineering team needs to resolve it quickly.

You enjoy testing edge cases, thinking like an end user, and finding issues before customers do. You're organized, detail-oriented, and take pride in delivering high-quality software.

Example

If a customer reports that an API request failed, we don't expect a bug report that simply says:

"The API isn't working."

Instead, we want someone who investigates questions like:

Was the request formed correctly?
Did authentication succeed?
What HTTP status code was returned?
What does the response body indicate?
Can the issue be reproduced consistently?
Is the problem isolated to one endpoint, one customer, or one environment?
Is it an application issue, infrastructure issue, or third-party dependency?

The more information you can gather before involving engineering, the faster problems get solved.

Hello, I am looking for a better way, besides multiple Excel spreadsheets, to enter machine and operator data, calculate and show our run time efficiency, our operator efficiency, and OEE. We are an automotive parts manufacturer with 65 machine operators and we run 3 shifts. Each operator fills out a paper daily production sheet which shows their start time, end time, any down time, and their pieces made. We then use that to manually calculate how many pieces they made, enter into a "Production Report - Week of..." spreadsheet to track daily, then at the end of that file it totals our OEE sheet and charts it at the final tabs in that worksheet. We then use that data to create "Productivity - Week of ..." that shows the operators efficiency daily so they and we can make sure they are hitting their required production percentage of 94%. The operators will often move to a different machine, so they sometimes have multiple daily sheets per day/shift. For now we want to continue with them turning in the paper copies. Please review and let me know if you have any questions and if this is something you may be able to help with.

I am building an AI-driven platform that helps telecom vendors understand exactly what has happened across their networks by turning raw data into clear, actionable insight. The focus is strictly descriptive analytics: I want to surface patterns, error trends, and usage anomalies from two key sources—real-time network performance metrics and our historical customer service logs—so engineers and account teams can quickly see where issues occurred and how widespread they were.

Here’s what I need from you:

• Data pipeline design and implementation that securely ingests high-volume performance counters alongside ticket and chat transcripts, cleans them, and stores them in a query-friendly format.
• Feature engineering and statistical/ML models (Python, pandas, scikit-learn or similar) tailored to summarising incidents, frequency, duration, and affected geographies or device types. Deep learning is optional if you have a compelling reason.
• A lightweight dashboard—Grafana, Kibana, or a React-based front end—that visualises daily, weekly, and monthly error trends, highlights top recurring issues, and allows drill-down to individual log entries.
• Documentation and a short hand-off session so my in-house team can maintain and extend the solution.

Acceptance criteria: data refresh completes within 15 minutes for each hourly batch; dashboards render key metrics in under two seconds; codebase is delivered via Git with clear README and unit tests.

If you have solid experience in telecom data, stream processing (Kafka/Spark/Flink), and building intuitive analytical UIs, let’s talk.

English level must be Native or C2

Skills: Python, Statistics, Machine Learning (ML), Statistical Analysis, Git, Spark, Data Visualization, Data Analysis, Deep Learning, Kibana

**Title:** Junior DevOps Engineer — Kubernetes CI/CD & Deployment Support

**Read before applying:** This is a **junior-level, fixed-scope assignment estimated at 32 hours** (fixed contract only). Please apply only if you are comfortable completing the defined deliverables within this junior-level scope, budget, and timeline.

We need a junior DevOps engineer to configure and document a reliable Kubernetes-based deployment workflow for a project-management platform. A Kubernetes cluster is already available; this assignment focuses on application deployment, CI/CD, operational basics, and handoff documentation—not building or administering the underlying cluster.

### Scope

Set up the initial **Kubernetes Deployment, CI/CD & Observability** workflow:

- Containerize the application services and prepare production-ready Dockerfiles
- Create and configure Kubernetes manifests or Helm charts for application deployment
- Configure Deployments, Services, ConfigMaps, Secrets references, namespaces, and ingress or routing configuration
- Set up readiness and liveness probes, resource requests/limits, and basic autoscaling configuration where appropriate
- Create CI pipelines for linting, automated tests, image builds, and container-image publishing
- Configure a basic CD workflow to deploy approved application builds to the existing Kubernetes cluster
- Set up environment-specific configuration for development, staging, and production
- Configure secure handling of secrets, environment variables, service credentials, and database connection settings
- Add basic logging, health checks, and monitoring/alerting integration using the existing platform tools
- Document deployment, rollback, release, troubleshooting, and handoff procedures

### Required Skills

- Kubernetes fundamentals: Deployments, Services, Ingress, ConfigMaps, Secrets, and namespaces
- Docker and container-image management
- Git and CI/CD pipelines
- GitHub Actions, GitLab CI, or similar CI/CD tooling
- Linux and shell scripting
- Basic application monitoring, logs, health checks, and incident troubleshooting
- Secure configuration and credential handling
- PostgreSQL application connectivity and environment configuration

### Nice to Have

- Helm or Kustomize
- Experience deploying Python/FastAPI services
- Kubernetes ingress controllers such as Nginx Ingress or Traefik
- Prometheus, Grafana, Loki, or similar observability tools
- Argo CD, Flux, or GitOps workflows
- Familiarity with cloud Kubernetes environments

In your proposal, begin with: **“SCOPE CONFIRMED.”** To prove you read the job description.

Then share one relevant Kubernetes, Docker, CI/CD, or application-deployment example and briefly confirm your availability.

ABOUT US

Novacell Solutions Inc. is a Canadian company building a travel connectivity app: travellers buy a data plan for the country they are visiting and activate it from their phone. Our iOS and Android apps are in store internal-test tracks and we are preparing for public launch.

ABOUT THE PROJECT

You would be joining an established codebase, not starting a new one: 143 API endpoints, 420 automated tests, and two carrier partners integrated in production. Your first weeks are spent reading code someone else wrote.

Stack: NestJS 11, TypeORM, PostgreSQL 17, React 19, React Native (Expo), Docker, GitHub Actions, DigitalOcean App Platform, Prometheus/Grafana/Loki.

RESPONSIBILITIES

- Design, build and maintain the NestJS and PostgreSQL services behind our order, payment and fulfilment lifecycle, including the carrier partner APIs behind our supplier abstraction layer
- Build and extend our operations backend — the admin console, refund handling, and reconciliation between our orders, the payment provider and the carrier partner — both the APIs and the React screens on top of them
- Own deployment and operations on DigitalOcean: Docker, CI/CD pipelines, multi-environment configuration, and the release process
- Extend monitoring, alerting and structured logging so that production problems are found by us rather than reported by customers
- Write and maintain automated tests (Jest, Supertest) alongside the code you ship

There is also occasional work on our React Native app's release cycle.

REQUIRED QUALIFICATIONS

- Based in Canada and able to invoice as an independent contractor
- Fluent Mandarin and working English — our product manager, developers and testing team are in China, and some specifications and support content are written in Chinese
- 5+ years of professional backend development with strong TypeScript
- Deep NestJS experience (modules, dependency injection, guards, interceptors), or equivalent depth in Express or Fastify
- PostgreSQL and an ORM: schema design, migrations, and query optimization
- REST API design, JWT authentication, and role-based access control
- Payment gateway integration including webhook handling (Stripe, PayPal, WeChat Pay or similar)
- Experience handling failure in multi-step transactions: downstream calls that time out without telling you whether they succeeded, idempotency keys, partial success, and compensating actions rather than rollback
- Production operations experience with Docker, CI/CD and at least one cloud platform — you have deployed, monitored and debugged live systems yourself
- Working React knowledge, enough to build and modify admin interfaces
- A track record of joining a large existing codebase and becoming productive in it quickly

PREFERRED QUALIFICATIONS — the higher up the list, the more it counts

- High-volume transactional systems — e-commerce, payments, marketplaces or similar — and the queue, caching and database-performance judgment that comes from running one
- Prometheus, Grafana and Loki; alert design and on-call experience
- BullMQ, Redis or Valkey; distributed locks and horizontal scaling patterns
- Payment reconciliation, settlement or chargeback experience
- Saga or orchestration patterns for distributed transactions
- React Native with Expo and EAS Build, with apps shipped to the App Store and Google Play

PROJECT DETAILS

- This is a part-time engagement: 20-25 hours per week, ongoing. We are looking for a long-running relationship (12+ months), not a one-off project
- It is intended to grow. After launch this can become a full-time contract, or a permanent role, if it suits both sides
- We are looking for someone in Metro Vancouver or the Greater Toronto Area. Work is remote, with an optional desk in our Richmond, BC office if you are in Metro Vancouver
- Async by default, with one live window that works naturally with our China team: late afternoon Pacific is the following morning in Beijing

HOW TO APPLY

Please include in your proposal:

1. Links to work we can look at: GitHub, live products you built or ran, or technical writing. If your strongest work is under NDA, tell us what it was and what you personally owned instead — we do not expect a public repo for proprietary backend work.
2. Your city and province, and your available hours per week.

We read every proposal and reply to the ones that answer both. Please answer the screening questions properly — that is what we shortlist on.

Senior AI/ML + Distributed Systems Engineer Required (Backend Enterprise Build – £2300 Fixed Price)

Project: AI Financial Intelligence & Risk Monitoring Platform (Backend)

We are hiring a highly experienced engineer or engineering team to architect, build, deploy, and operationalize the production-grade backend for an 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 backend system capable of operating under production conditions.

⸻

Project Overview

The backend 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 via API
* Operate under strict performance, latency, and scalability benchmarks

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

⸻

Budget & Payment Structure – £2300 Fixed (2 Milestones)

Milestone 1 – £2,185

* Paid 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

⸻

Milestone 2 – £115 (Final Payment)

* Payable only upon:
* Full production deployment
* All backend 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
* Well-documented API endpoints for downstream/frontend consumption

⸻

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 backend 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

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:

* Backend 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 backend 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
* Feedback or testing does not constitute acceptance

Acceptance occurs only upon full backend 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, and FastAPI

⸻

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 backend 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), Documentation, Kubernetes, Anomaly Detection, API Development, CI/CD, FastAPI, Distributed Systems

Location: Remote (EU Preferred)
Job Type: Full-Time Contract (4–5 Months)

Job Overview

We are seeking an experienced Senior DevOps/Cloud Infrastructure Engineer to join our engineering team on a full-time basis. You'll play a key role in designing, automating, and maintaining scalable AWS infrastructure while improving observability, monitoring, and operational efficiency.

If you're passionate about cloud infrastructure, Infrastructure as Code, automation, and DevOps best practices, we'd love to hear from you.

Responsibilities
Design, deploy, and maintain scalable AWS infrastructure.
Build and manage Infrastructure as Code using Terraform.
Develop automation scripts and tools with Python.
Configure and maintain monitoring and observability solutions using Grafana.
Implement best practices for monitoring, alerting, and incident management.
Standardize and improve operational workflows using Jira Service Management or similar tools.
Automate infrastructure operations and incident response.
Collaborate with engineering teams to improve reliability, scalability, and performance.
Troubleshoot production issues and optimize cloud environments.

Required Skills
5+ years of experience as a DevOps, Cloud Infrastructure, or Site Reliability Engineer.
Strong hands-on experience with AWS.
Advanced Terraform (Infrastructure as Code).
Strong Python scripting and automation skills.
Experience with Grafana, monitoring, and alerting platforms.
Experience implementing enterprise observability solutions.
Knowledge of cloud networking, infrastructure security, and DevOps best practices.
Experience with Jira Service Management or similar incident management tools.
Strong problem-solving and communication skills.
Ability to work independently in a remote environment.

Nice to Have
Experience with hardware, robotics, or IoT infrastructure.
AI-assisted operations or automated incident management.
CI/CD pipeline optimization.
Large-scale infrastructure automation.

Tech Stack:
AWS
Terraform
Python
Grafana
Jira Service Management
CI/CD
Infrastructure as Code (IaC)
Cloud Monitoring & Alerting

Contract Details
Duration: 4–5 months
Commitment: Full-time (40 hours/week)
Location: Remote (EU candidates preferred)

To Apply

Please include the following in your proposal:

Your years of DevOps/AWS experience.
Recent AWS infrastructure projects you've worked on.
Your experience with Terraform and Python automation.
Your experience with Grafana or observability platforms.
Your availability and timezone.

# Senior VoIP / SIP Engineer — Kamailio + RTPengine + Asterisk SBC Build (3 months, near full-time)

## The role

We are building out a production carrier-grade voice estate and need an experienced VoIP engineer to lead the telephony infrastructure work end to end. This is hands-on build work, not advisory. You will design, stand up, harden and document a SIP edge and media layer that terminates PSTN traffic from US carriers and routes it into application logic behind it.

You will be the telecom specialist on the project. Our in-house team covers application development, AI/ML, cloud infrastructure and delivery — we need the person who owns the SIP layer and knows why calls actually break.

## Must-have experience

You should have built and run this stack in production, not just read about it:

**SIP edge / SBC**
- Kamailio (or OpenSIPS) as a production SBC — routing logic, `dispatcher`, `dialog`, `htable`, `pike` / `ratelimit`, `permissions`, topology hiding, TLS termination
- KEMI scripting (Lua or Python) or strong native cfg scripting
- RTPengine — media relay, kernel module, SRTP/DTLS, NAT traversal, in-kernel vs userspace forwarding trade-offs

**Media / application layer**
- Asterisk 20/22 — PJSIP stack, dialplan, ARI and AMI, queues, realtime architecture, ODBC/PostgreSQL backends
- Codec handling and transcoding cost management (G.711, G.729, Opus)

**PSTN and carrier integration**
- Live SIP trunk integration with US carriers (Bandwidth, Telnyx, Inteliquent, Peerless, Twilio or equivalent)
- E.164 normalisation and header normalisation across multiple carriers — ANI, P-Asserted-Identity, RPID, Diversion, `verstat`
- DID inventory management, LERG/LRN awareness, porting workflows
- STIR/SHAKEN — inbound verification and outbound attestation, `res_stir_shaken`, Identity header handling, certificate/CRL management

**Operations**
- High availability for a stateful SIP edge — active/active or VRRP, state replication, failover behaviour under load
- Homer/HEP, sngrep, tcpdump — you debug at packet level as a matter of routine
- SIPp load testing, CPS and concurrency capacity planning
- Linux (Debian/Ubuntu), systemd, nftables/iptables, kernel tuning for high-PPS voice workloads
- Infrastructure as code — Ansible and/or Terraform. We do not want snowflake servers.
- Prometheus/Grafana instrumentation, CDR accuracy and audit logging

## Strongly preferred

- Contact centre telephony — queueing, IVR, call recording architecture
- Robocall/fraud mitigation at the SIP layer — reputation feeds, velocity controls, ANI validation, do-not-originate handling
- US regulatory familiarity: FCC call blocking rules and SIP 603+, Robocall Mitigation Database, PCI DTMF suppression, E911 / Kari's Law / RAY BAUM'S Act
- FreeSWITCH, WebRTC/SIP over WSS
- Experience handing an estate over to an in-house team that will run it afterwards

## What we care about

**Documentation and handover are part of the deliverable, not an afterthought.** Our team will operate this once you are done. Everything you build needs to be reproducible from code, with runbooks. If you have only ever configured boxes by hand, this is not a fit.

We also want someone who says "that won't work" when it won't. You'll have direct access to the technical decision maker and we'd rather argue about the design early than discover the problem in production.

## Engagement

- **Duration:** 3 months, with a strong chance of extension into an ongoing retainer
- **Commitment:** 30–40 hrs/week — this is a near full-time engagement, not a few hours on the side
- **Overlap:** minimum 4 hours daily overlap with UK business hours; some US (Central/Eastern) call availability
- **Location:** fully remote, anywhere
- **Rate:** competitive and negotiable for the right person — tell us your rate, don't guess ours
- We work in two-week increments with defined outcomes. First increment is a paid scoped piece of work so we both find out quickly whether this works.

Individual contractors preferred. If you're applying as an agency, name the specific engineer who will do the work and include their background.

## To apply

Skip the template cover letter — we read the answers, not the boilerplate. Please answer:

1. Describe a production Kamailio (or OpenSIPS) + RTPengine + Asterisk estate you personally built. Topology, peak concurrent calls, carriers, and what broke in the first month.
2. How do you reject an inbound call at INVITE without establishing media, and which SIP response codes do you use in which circumstances — and why does the choice matter?
3. Two US carriers deliver the same call with different header treatment. Walk us through how you normalise ANI and caller ID authentication status so downstream logic sees one consistent shape.
4. What is your approach to high availability on the SIP edge specifically, and what state do you actually have to replicate?
5. A customer reports one-way audio on roughly 5% of calls. Talk us through your first hour.

Short, specific answers beat long ones. A link to config you've written, a GitHub profile, or a description of a genuinely hard bug you fixed will get our attention faster than a CV.

Skill tags: Full-Stack Development · JavaScript · TypeScript · React · Node.js · Python · API Development · SQL · PostgreSQL · GitHub · Docker · CI/CD · AWS · DevOps · Technical Support


Full-Stack Development Deliverables:
• Review and approve/reject vendor-developed code and pull requests.
• Maintain and enforce coding standards, architecture guidelines and best practices.
• Ensure 100% of source code is maintained in company-controlled GitHub repositories.
• Review database schema changes, migrations and queries.
• Review REST APIs, third-party integrations and authentication mechanisms.
• Maintain technical architecture and system documentation.
• Establish/maintain CI/CD pipelines and deployment processes.
• Support application releases and production deployments.
• Provide L2/L3 troubleshooting and production incident resolution.
• Perform root-cause analysis and implement permanent fixes.
• Coordinate with vendors on bugs, enhancements and emergency fixes.
• Maintain application ownership so the company is never dependent on vendors for access or technical understanding.
• Perform emergency production fixes when required.
• Conduct security, performance and reliability reviews.
• Maintain runbooks, deployment guides and troubleshooting documentation.


Full-Stack Development Skills:
Frontend
• React.js / Next.js
• JavaScript / TypeScript
• HTML5 / CSS3
• Responsive UI development
Backend
• Node.js / Express.js
• Python / Django or FastAPI
• RESTful APIs
• Authentication & authorization
• Microservices / service-oriented architecture

DevOps & Production
• Git & GitHub
• CI/CD
• Docker
• Cloud deployment
• Linux
• Monitoring and logging
• Production troubleshooting Engineering
• Clean code and SOLID principles
• Design patterns
• Code review
• Unit/integration testing
• Secure coding
• Performance optimization
• API and database design
• System architecture

Full-Stack Development Languages:
Priority Language
Must Have JavaScript / TypeScript
Must Have SQL
Preferred Python
Preferred Java
Preferred C# / .NET
Good to Have Bash / Shell scripting

Databases:
Required:
• PostgreSQL
• MySQL / MariaDB
• Microsoft SQL Server
• Database schema design
• SQL query optimization
• Indexing and performance tuning
• Database migrations
• Backup and recovery
• Data integrity and transaction management
Good to Have:
• MongoDB
• Redis
• Elasticsearch/OpenSearch

Web Servers / Application Servers:
• Nginx
• Apache HTTP Server
• IIS
• Node.js application servers
• Gunicorn / Uvicorn for Python applications
• Reverse proxy configuration
• SSL/TLS configuration
• Load balancing
• HTTP/HTTPS troubleshooting

Additional Technologies :
Cloud: AWS / Azure / Google Cloud
Containers: Docker; Kubernetes is a plus
CI/CD: GitHub Actions, GitLab CI, Jenkins or Azure DevOps
Monitoring: Grafana, Prometheus, ELK/OpenSearch, CloudWatch/Azure Monitor
Security: OWASP, secrets management, authentication/authorization, vulnerability remediation
Version Control: Git + GitHub
Documentation: Confluence/Notion/Markdown/OpenAPI/Swagger

We'd need some help from a database specialist to work an existing financial platform with large records of companies and contacts.

The Challenge:

We are experiencing severe latency issues specifically tied to contact record updates within our CRM. When users add or update contact records, there is a significant delay before the data is persisted to the database and reflected in the UI. This write-latency is impacting user productivity and data reliability across the platform. We are looking for a specialist to diagnose the root cause and implement a robust, lasting solution.

Scope of Work:

Conduct a deep-dive audit of our database architecture, query patterns, and application-layer data flow for contact/CRM-related operations.

Identify bottlenecks causing write-latency (e.g., missing indexes, lock contention, inefficient ORM queries, transaction scope issues, replication lag, cache invalidation delays, or connection pool exhaustion).

Profile and optimize slow queries, schema design, and indexing strategies for high-volume contact and conversation records.

Review and optimize our caching layer (e.g., Redis/Memcached) and cache-invalidation logic to ensure updates are reflected immediately.

Audit background job queues and async processing pipelines that may be delaying persistence or display updates.

Implement monitoring, alerting, and observability for database performance and query execution times.

Deliver documentation and knowledge transfer so our team can maintain performance gains.

Required Skills & Experience:

7+ years of backend engineering experience with a heavy focus on database performance and optimization.

Deep expertise in relational databases (PostgreSQL, MySQL, or SQL Server): query planning, execution plans, indexing strategies, partitioning, and transaction isolation levels.

Proven track record diagnosing and fixing write-latency and read-replication lag in high-traffic web applications.

Strong experience with ORM optimization (e.g., Django ORM, SQLAlchemy, TypeORM, Hibernate, Entity Framework) and eliminating N+1 queries.

Hands-on experience with caching architectures and real-time data sync patterns (cache-aside, write-through, WebSockets, server-sent events).

Proficiency in our backend stack (or similar): [insert your stack, e.g., Python/Django, Node.js/Express, Ruby on Rails, .NET, Java/Spring].

Experience with observability tools (Datadog, New Relic, Prometheus/Grafana, AWS CloudWatch, pg_stat_statements).

Nice-to-Have:

Experience with CRM platforms, financial data systems, or marketplace applications.

Familiarity with CQRS, event sourcing, or eventual consistency patterns.

Knowledge of database migration strategies for large datasets with minimal downtime.

Full-stack capability to audit frontend data-fetching patterns if display latency is client-side.

We're a bootstrapped-to-profitable B2B SaaS company (analytics platform, ~200 paying customers, ~15M requests/day). Stack is Go and Python microservices, PostgreSQL and Redis, all running on self-managed Kubernetes (kubeadm) across a fleet of Ubuntu VMs split between AWS EC2 and Hetzner bare metal.

We have 12 engineers, one of whom "does DevOps when he has time." The cluster was set up two years ago by a contractor who's no longer around. It works - until it doesn't. We've had three incidents this quarter (a full-disk etcd node, a cert expiry that took down the API server, and a noisy-neighbor pod that OOM-killed production). We need a senior Kubernetes / Linux platform engineer who has run clusters in anger to audit what we have, fix the scary parts, and leave us with something maintainable.

What we're looking for

Full Kubernetes cluster health and architecture review: control plane HA, etcd backup/restore (we currently have neither tested), upgrade path (we're 3 minor versions behind), findings prioritized by blast radius.
Decision support and migration plan: stay on self-managed kubeadm vs. move to EKS - with a real cost and operational-overhead comparison, not a sales pitch.
Linux hardening across the node fleet: CIS benchmarks, kernel parameters, SSH lockdown, automated patching strategy (unattended-upgrades vs. immutable node images), auditd.
Kubernetes security hardening: RBAC least-privilege review (everything currently runs as cluster-admin), Pod Security Standards, NetworkPolicies (we have zero), secrets encryption at rest, image scanning and admission control (Kyverno or Gatekeeper).
Resource management: requests/limits across all workloads, HPA where it makes sense, PodDisruptionBudgets, priority classes - so one bad deploy can't take down the cluster again.
Observability: Prometheus / Grafana / Alertmanager stack with alerts that actually page on the right things, plus centralized logging (Loki or ELK). We currently SSH into nodes and grep.
GitOps: move deployments from kubectl apply off laptops to ArgoCD or Flux with proper environments and rollback.
Ingress and TLS: sane ingress-nginx (or alternative) setup with cert-manager so certificates never silently expire again.
Disaster recovery runbook: tested etcd restore, node replacement procedure, and a written incident playbook.
Documentation and knowledge transfer sessions so our team can operate this without you.

Requirements

Deep hands-on Kubernetes experience: you've administered self-managed clusters (kubeadm/kubespray), not just consumed EKS/GKE.
Strong Linux systems engineering: systemd, networking, storage, performance debugging, security hardening on Ubuntu/Debian.
Production experience with Prometheus, Grafana, and at least one GitOps tool (ArgoCD / Flux).
IaC fluency: Terraform for the cloud layer, Ansible (or similar) for node configuration.
You've handled real incidents - etcd recovery, control plane failures, cascading OOMs - and can talk about them specifically.
Available for meaningful overlap with Central European business hours.

Nice to have

CKA / CKS certification.
Experience running hybrid cloud + bare-metal clusters (Hetzner, OVH, Equinix).
Cilium / eBPF networking experience.
Cost optimization experience - our AWS bill and Hetzner fleet have both grown without anyone checking.
Willing to stay on retainer for ongoing platform support and on-call escalation.

Please include specific examples of Kubernetes clusters you've audited or rescued, what you found, and what you fixed - plus your estimated timeline. Long-term potential for the right person.

We are looking for an exceptional Staff Backend Engineer to help architect and build an enterprise-scale distributed platform consisting of high-throughput backend services, event-driven workflows, transactional systems, and cloud-native infrastructure.

This is not a typical feature-development or CRUD backend role.

We need a senior engineer who can take ownership of complex technical problems, make sound architectural decisions, design systems for significant scale, and work closely with technical leadership on the long-term evolution of the platform.

The ideal candidate has deep production experience with Go, Python, and C#/.NET, along with a strong background in distributed systems, system design, cloud architecture, databases, reliability, and performance engineering.

This is intended to be a long-term, high-impact engineering engagement.

What You’ll Work On

You will help design and build core parts of a large distributed platform, including:

* High-throughput backend services
* Distributed transaction processing
* Event-driven architectures
* Asynchronous processing pipelines
* Large-scale API platforms
* Service-to-service communication
* Data-intensive backend systems
* Cloud-native infrastructure
* Reliability and fault-tolerance mechanisms
* High-concurrency workloads
* Production observability and monitoring

You will be expected to contribute not only code, but also architecture, technical strategy, design reviews, and engineering standards.

Responsibilities

* Design scalable backend and distributed-system architectures
* Build production services using Go, Python, and C#/.NET
* Define service boundaries, APIs, data models, and communication patterns
* Design REST and gRPC APIs for internal and external integrations
* Build event-driven systems using Kafka, queues, or similar messaging technologies
* Design resilient workflows involving retries, idempotency, failure recovery, and distributed state
* Optimize PostgreSQL queries, schemas, indexing strategies, and transactional workloads
* Implement caching and performance strategies using technologies such as Redis
* Design systems for horizontal scalability and high availability
* Identify architectural bottlenecks before they become production issues
* Improve application latency, throughput, and resource efficiency
* Design reliable AWS-based infrastructure
* Establish monitoring, alerting, SLOs/SLIs, and production observability
* Participate in architecture and technical-design reviews
* Produce clear technical design documents
* Investigate complex production incidents and identify systemic solutions
* Mentor engineers and contribute to engineering standards
* Work directly with technical leadership on major platform decisions

Required Qualifications

Backend Engineering

* 10+ years of professional software engineering experience**
* Extensive backend engineering experience in production environments
* Strong experience building complex, business-critical backend systems
* Excellent understanding of software engineering fundamentals
* Demonstrated architecture ownership in production systems

Go

Strong professional production experience with Go / Golang is required.

You should be comfortable with:

* Concurrency
* Goroutines and channels
* Context propagation
* Worker patterns
* API services
* High-throughput processing
* Performance optimization
* Production debugging
* Microservice design

Python

Strong production experience with **Python**, especially for:

* Backend services
* Distributed workflows
* Automation
* Data processing
* Internal platforms
* Production service integrations

C# / .NET

Strong production experience with **C# and .NET**, ideally involving:

* Enterprise backend systems
* APIs
* Distributed services
* High-concurrency applications
* Business-critical platforms

Distributed Systems

You should have strong practical knowledge of distributed-system concepts including:

* Event-driven architecture
* Message queues
* Kafka
* Distributed transactions
* Idempotency
* Retry strategies
* Dead-letter queues
* Eventual consistency
* Data consistency
* Failure recovery
* Service resiliency
* Backpressure
* Horizontal scaling
* Distributed locking
* Concurrency control
* Graceful degradation
* High availability

We are particularly interested in engineers who understand how distributed systems behave and fail in real production environments**, rather than candidates whose experience is limited to creating basic microservices.

System Design & Architecture

This position requires advanced system-design capability.

You should be capable of taking a complex business requirement and independently determining:

* Service boundaries
* API architecture
* Data architecture
* Database strategy
* Messaging architecture
* Caching strategy
* Consistency model
* Failure-handling strategy
* Scaling strategy
* Security model
* Observability strategy
* Deployment architecture

You should be comfortable discussing architectural trade-offs and explaining why a particular design was selected.

Database & Data Architecture

Strong experience with:

* PostgreSQL
* SQL
* Schema design
* Query optimization
* Indexing
* Transactions
* Database locking
* Data consistency
* High-volume transactional workloads

Experience with Redis or similar caching technologies is strongly preferred.

Cloud & Infrastructure

Strong experience with AWS and cloud-native architectures.

Relevant technologies may include:

* AWS ECS
* Lambda
* RDS
* S3
* SQS
* Kubernetes
* Docker
* Terraform
* CI/CD

You do not need to be a dedicated DevOps engineer, but you should understand how large production backend systems are deployed, scaled, monitored, and operated.

Reliability Engineering

Strong knowledge of production reliability concepts is expected, including:

* High availability
* Fault tolerance
* SLOs / SLIs
* Monitoring
* Alerting
* Incident response
* Root-cause analysis
* Performance monitoring
* Capacity planning
* Disaster recovery

Experience with Datadog, Prometheus, Grafana, or similar observability platforms** is valuable.

Technical Leadership

This role involves significant technical ownership.

You may be expected to:

* Lead architecture discussions
* Review system designs
* Challenge weak technical assumptions
* Establish backend engineering patterns
* Mentor senior and mid-level engineers
* Improve engineering standards
* Evaluate architecture alternatives
* Help determine long-term technical direction

This is an individual-contributor engineering role with substantial architecture responsibility.

Communication

You should be able to communicate technical ideas clearly and collaborate effectively with engineers and technical leadership.

You must be comfortable participating in:

* Architecture discussions
* Technical design reviews
* Engineering planning
* Code and design reviews
* Problem-solving sessions

We care primarily about your ability to understand complex engineering problems and explain your technical decisions clearly.

Strong Plus

Experience in any of the following areas is highly valued:

* FinTech
* Payments
* Financial transaction processing
* Healthcare platforms
* Large-scale SaaS platforms
* Compliance-sensitive systems
* High-volume transaction processing
* Ledgering
* Reconciliation systems
* Kubernetes
* Kafka
* Terraform
* Redis
* Security-sensitive backend systems
* AI/LLM infrastructure
* RAG systems
* High-concurrency platforms

## Who We Are NOT Looking For

This role is probably not a fit if your background is primarily:

* Simple CRUD application development
* WordPress or CMS development
* Frontend-heavy development
* Small websites
* Basic REST API implementation
* Short-term freelance projects without architecture ownership

We are specifically looking for engineers who have personally designed, built, scaled, and operated complex production backend systems.

Engagement

* Long-term engagement
* 30–40 hours per week preferred
* Significant technical ownership
* Direct collaboration with technical leadership
* Major influence over architecture and engineering decisions
* Opportunity to become a key technical contributor to the platform

We value engineering judgment, architecture ability, reliability thinking, and technical ownership more than familiarity with a long list of frameworks.

Application Questions

Please answer the following questions in your proposal.

1. Distributed Systems Experience

Describe the most complex distributed system you personally designed or significantly contributed to.

Please include:

* What the system did
* Approximate scale
* Architecture
* Technologies used
* Your personal responsibilities
* The hardest technical problem you solved

2. Idempotency & Distributed Transactions

A client sends a financial transaction request.

The backend processes the transaction successfully, but the response is lost because of a network failure.

The client retries the same request.

How would you design the system to prevent the transaction from being processed twice?

Please explain the architecture and trade-offs.

3. Scaling & Performance

Imagine a PostgreSQL-backed API currently handles its workload with a p95 latency of approximately 150 ms.

Traffic increases by 5x, and p95 latency rises above 2 seconds.

Walk us through:

* How you would investigate the problem
* What metrics you would examine
* What bottlenecks you would consider
* What architectural changes you might make
4. Go Experience

Describe one significant production system you built using Go.

Please explain:

* What the system did
* Why Go was used
* Approximate production scale
* Concurrency or performance challenges
* Your personal contribution

5. Python and .NET Experience

Briefly describe your professional production experience with:

* Python
* C# / .NET

Please distinguish production experience from personal projects or coursework.

## 6. Architecture Ownership

Tell us about a system where you personally made major architectural decisions

Please explain:

* The original problem
* Architecture alternatives you considered
* Trade-offs
* Your final decision
* Production outcome

7. Production Failure

Describe one serious production incident or system failure you personally investigated.

What happened, how did you diagnose it, and what architectural or engineering changes did you make afterward?

Important

Please do not send a generic proposal.

Start your proposal with:

DISTRIBUTED SYSTEMS

Then provide:

1. Total years of professional software engineering experience
2. Years of backend engineering experience
3. Years of Go production experience
4. Years of Python production experience
5. Years of C#/.NET production experience
6. The largest or most complex production system you have worked on
7. One example of a system you personally architected

We are looking for a genuinely senior engineer capable of architecture-level ownership, not simply someone who can implement assigned tickets.

Project Overview
We are looking for an experienced Senior Full-Stack Developer / FinTech Engineer / Solution Architect to design and develop a secure, scalable B2B + B2C investment and wealth management platform.
The platform will support approximately 200 concurrent users initially, with an architecture designed to scale further. It will serve B2C customers, distributors/vendors, relationship managers, operations teams and platform administrators.
The system will cover:
Customer registration and onboarding
KYC / PAN / identity verification
Mutual Funds, SIP, SIF and other investment products
Portfolio management
Investment transactions
Payment integration
Financial planning and calculators
Distributor/B2B management
Customer, product and portfolio analytics
Historical and trend analysis
Customer, distributor and admin reporting
External integrations with financial-data/KYC providers
Secure cloud deployment, CI/CD, monitoring and disaster recovery
Core Technical Scope
Frontend
The proposed frontend stack is:
Next.js
React
TypeScript
Tailwind CSS
Shadcn UI
TanStack Query
Apache ECharts
The application will contain separate dashboards and workflows for customers, distributors, relationship managers and administrators.
Backend
The proposed backend stack is:
NestJS
TypeScript
REST APIs
Background workers
Redis
RabbitMQ/BullMQ initially
The backend must implement strong authentication, authorization, RBAC, tenant/distributor-level data isolation and audit logging.
Database & Analytics
The proposed architecture uses:
PostgreSQL – transactional/OLTP database
ClickHouse – analytical database and historical reporting
Redis – caching
Python + Apache Airflow – ETL/ELT
dbt – optional analytical transformation layer
DigitalOcean Spaces – raw/source data storage
FinTech / Investment Features
The system will include:
Mutual Fund product discovery
SIP setup and tracking
SIF information and eligibility
Portfolio holdings
Investment transactions
Current value and invested amount
Profit/loss
XIRR/annualized returns
Asset/product allocation
Historical investment information
Purchase, SIP registration, additional investment, redemption and switch/cancellation where supported by providers.
KYC & Onboarding
The developer will work on integration with approved KYC/verification providers, potentially including:
PAN verification
CKYC/eKYC
Identity verification
Document verification
KYC status management
Rejection/resubmission workflows
Analytics & Reporting
The platform requires substantial reporting capabilities.
Examples include:
Customer onboarding analytics
KYC completion/pending
Customer activity and retention
AUM and AUM growth
SIP book and growth
Product popularity
Product-wise AUM
Subscription trends
Historical portfolio analysis
Monthly/quarterly/yearly/FY analysis
Distributor performance
Product trends
Custom date-range comparisons
Customer/distributor/admin reports
PDF/Excel exports
External Integrations
Potential integrations include:
CAMS
NSE
BSE
KYC/CKYC providers
PAN verification
eKYC
Payment gateway
SMS
Email
WhatsApp
Licensed market/product-data providers
Actual integrations will depend on API documentation, commercial agreements, credentials, sandbox access and required approvals.
Cloud & DevOps
The proposed infrastructure includes:
Docker
GitHub Actions
DigitalOcean
Managed PostgreSQL
Redis
DigitalOcean Spaces
VPC
Firewall
Container Registry
Load Balancer
Cloudflare
Prometheus
Grafana
Loki
The project will have separate development, staging and production environments with automated CI/CD, monitoring, backups and disaster recovery procedures.
Security Requirements
Security is a major component of this project.
The developer should have practical experience with:
JWT/refresh-token authentication
MFA/OTP
RBAC
Multi-tenant data isolation
API security
Encryption
Rate limiting
Secrets management
Private networking
Firewall configuration
Audit logging
Secure data export
Financial transaction security
The backend must enforce authorization and ensure that one distributor cannot access another distributor's customers or data.
Testing & Performance
The system will require:
Unit testing
API testing
Integration testing
Regression testing
Performance testing
Security testing
UAT support
Load/stress testing
Initial capacity target is approximately 200 concurrent users, with final production sizing to be determined through performance testing.
Ideal Candidate
We are looking for someone who has real-world experience building production FinTech, wealth-management, investment, banking, payment or other financial applications.
Strong experience in the following areas is preferred:
7+ years of software development
Senior-level Node.js/TypeScript experience
NestJS
React/Next.js
PostgreSQL
Redis
Python
Airflow
Data pipelines / ETL
ClickHouse or another analytical database
REST API architecture
Third-party API integrations
Cloud infrastructure
Docker
CI/CD
Security and RBAC
Multi-tenant SaaS architecture
Experience with Mutual Funds, SIP, portfolio management, KYC, brokerage, wealth management, payments or investment platforms will be a significant advantage.
We are open to your recommendations and would prefer the best practical technology/architecture for the project rather than blindly following a predefined stack.
Please Answer These Questions in Your Proposal
Please describe your most recent FinTech/financial-services project. What was the business domain, your role, team size and technology stack?
Have you previously built a Mutual Fund, SIP, wealth-management, portfolio-management, brokerage or investment platform? Please explain exactly what you built.
Have you integrated with CAMS, NSE, BSE, KFintech, CKYC, PAN/KYC providers or similar financial APIs? Please specify which APIs and what functionality you implemented.
Please provide 2–3 relevant production projects that demonstrate your experience. Include links/screenshots where confidentiality permits.
Have you implemented multi-tenant B2B SaaS architecture where each distributor/tenant can only access its own customers and data? Explain your approach to tenant isolation.
Have you designed systems using PostgreSQL + ClickHouse or another OLTP + analytical database architecture? How did you synchronize transactional data with the analytical layer?
What experience do you have with Python + Apache Airflow? Please describe one real ETL/data pipeline you implemented.
Have you handled financial transaction processing and reconciliation? If yes, explain how you handled transaction status, callbacks/webhooks, failures, idempotency and reconciliation.
What approach would you use to ensure financial calculations such as XIRR, CAGR, SIP returns and portfolio P&L are accurate and auditable?
What is your experience with RBAC, data security, audit trails and sensitive financial/customer data?
Have you implemented CI/CD and production infrastructure on DigitalOcean, AWS, Azure or GCP? Please describe the architecture.
What monitoring/logging tools have you used? Have you worked with Prometheus, Grafana and Loki?
How would you design this system to scale from approximately 200 concurrent users to 5,000–10,000+ users without a major architectural rewrite?
What would you identify as the three biggest technical risks in this project?
If you were responsible for the architecture, what would you change or improve in our proposed technology stack and why?
How would you approach integration when an external financial provider has limited APIs, unreliable APIs, delayed callbacks or incomplete documentation?
Please provide your availability per week, expected project duration and preferred engagement model.
What part of this project do you consider your strongest area, and which part would you prefer another specialist to handle?
Important
We are looking for someone who can contribute beyond writing code. The selected developer should be capable of understanding the financial domain, challenging architectural decisions when necessary, designing scalable solutions and taking ownership of production implementation.
Please do not submit a generic proposal. Your proposal should specifically address the questions above and demonstrate relevant experience with FinTech, financial data, investment platforms, portfolio management, KYC, analytics and secure financial systems.

Important: The positions are based in Hanoi. You need to be full time ready and available for the project.
* Design and develop business modules based on workflow processes (registration → assessment/review → approval → issuance) for various systems.
* Integrate APIs with SSO, authorization/access control, and shared master-data/catalog systems of large platforms via LGSP.
* Design Oracle databases and optimize SQL queries.
* Manage source code on GitLab using Git Flow; write unit tests (JUnit/Jest) and ensure the CI/CD pipeline passes before merging code.
* Use Jira to update task status daily and Notion to access and contribute technical documentation.
* Experience with AI coding tools (Cursor, GitHub Copilot, Claude Code) is encouraged to accelerate boilerplate/scaffolding development, but all AI-generated code must go through the mandatory review process before being deployed to production.
* Work closely with the DevOps team to ensure system performance and security during deployment.

**Requirements:**

* At least **3–5 years of experience** with Java Spring Boot or Node.js.
* Experience working with Oracle/PostgreSQL and designing relational databases.
* Good understanding of REST APIs, OAuth2/SSO, and Microservices architecture.
* Proficient in Git/GitLab, with experience writing unit tests and working with CI/CD pipelines.
* Experience using AI coding agents (Cursor, GitHub Copilot, Claude Code) in real-world projects and a strong understanding of the security limitations and risks of using AI-generated code is preferred.
* Experience with e-government projects, police/defense-sector projects, or high-security systems is preferred.

* Deploy and operate server infrastructure, including Load Balancers, API Gateways, Kubernetes clusters, and Oracle RAC, within a closed internal network environment (BCANet).
* Build backup/restore mechanisms and implement system monitoring using ELK and Prometheus/Grafana, including incident alerting.
* Set up and maintain CI/CD pipelines on GitLab, including automated security scanning of all code—including AI-generated code—before merging into production.
* Conduct security testing and ensure compliance with **Level 3 Information Security standards**.
* Develop Disaster Recovery and incident response procedures, and maintain operational documentation in Notion.
* Track progress and report infrastructure/bug status daily through Jira.
* Work closely with the backend team to optimize system performance and provide guidance on safe boundaries and controls when using AI coding tools in the project.

* At least **3–5 years of experience** in Linux system administration and Kubernetes/Docker.
* Experience with Oracle DB backup/HA, ELK Stack, and Prometheus/Grafana.
* Good understanding of information security and ISO 27001 or equivalent standards.
* Experience setting up CI/CD pipelines and integrating static security scanning tools (SAST/dependency scanning).
* Understanding of the security risks associated with AI-generated code ("vibe coding") and how to implement automated controls within CI/CD pipelines is preferred.
* Security certifications such as **CEH or CompTIA Security+**, or experience working with government systems, is preferred.

Project timeline

You will be responsible for developing and integrating two systems within a 2-week period.**

Location: Hanoi.

We’re looking for an experienced DevOps Engineer to help us build, maintain, and improve our cloud infrastructure and deployment workflows.

Responsibilities
- Set up and maintain CI/CD pipelines
- Manage cloud infrastructure and production environments
- Work with Docker and Kubernetes
- Configure and maintain Linux servers
- Automate deployments and infrastructure tasks
- Monitor system performance, reliability, and availability
- Troubleshoot infrastructure and deployment issues
- Implement security and best practices for cloud environments
Requirements
- Strong Linux and networking knowledge
- Experience with AWS, Azure, or GCP
- Hands-on experience with Docker and Kubernetes
- Experience with CI/CD tools such as GitHub Actions, GitLab CI, or Jenkins
- Familiarity with Terraform or other Infrastructure as Code tools
- Good understanding of Git
- Strong troubleshooting and problem-solving skills
- Good communication and ability to work independently
Nice to Have
- Experience with monitoring tools such as Prometheus and Grafana
- Experience with Ansible
- Experience with security, networking, and cloud cost optimization
- Experience supporting production applications

Important: The positions are based in Hanoi

* Design and develop business modules based on workflow processes (registration → assessment/review → approval → issuance) for various systems.
* Integrate APIs with SSO, authorization/access control, and shared master-data/catalog systems of large platforms via LGSP.
* Design Oracle databases and optimize SQL queries.
* Manage source code on GitLab using Git Flow; write unit tests (JUnit/Jest) and ensure the CI/CD pipeline passes before merging code.
* Use Jira to update task status daily and Notion to access and contribute technical documentation.
* Experience with AI coding tools (Cursor, GitHub Copilot, Claude Code) is encouraged to accelerate boilerplate/scaffolding development, but all AI-generated code must go through the mandatory review process before being deployed to production.
* Work closely with the DevOps team to ensure system performance and security during deployment.

**Requirements:**

* At least **3–5 years of experience** with Java Spring Boot or Node.js.
* Experience working with Oracle/PostgreSQL and designing relational databases.
* Good understanding of REST APIs, OAuth2/SSO, and Microservices architecture.
* Proficient in Git/GitLab, with experience writing unit tests and working with CI/CD pipelines.
* Experience using AI coding agents (Cursor, GitHub Copilot, Claude Code) in real-world projects and a strong understanding of the security limitations and risks of using AI-generated code is preferred.
* Experience with e-government projects, police/defense-sector projects, or high-security systems is preferred.

---

### 2. DevOps / Security Engineer

DevOps Engineer (Linux, Kubernetes, System Security) – IT Infrastructure Project**

* Deploy and operate server infrastructure, including Load Balancers, API Gateways, Kubernetes clusters, and Oracle RAC, within a closed internal network environment (BCANet).
* Build backup/restore mechanisms and implement system monitoring using ELK and Prometheus/Grafana, including incident alerting.
* Set up and maintain CI/CD pipelines on GitLab, including automated security scanning of all code—including AI-generated code—before merging into production.
* Conduct security testing and ensure compliance with **Level 3 Information Security standards**.
* Develop Disaster Recovery and incident response procedures, and maintain operational documentation in Notion.
* Track progress and report infrastructure/bug status daily through Jira.
* Work closely with the backend team to optimize system performance and provide guidance on safe boundaries and controls when using AI coding tools in the project.

**Requirements:**

* At least **3–5 years of experience** in Linux system administration and Kubernetes/Docker.
* Experience with Oracle DB backup/HA, ELK Stack, and Prometheus/Grafana.
* Good understanding of information security and ISO 27001 or equivalent standards.
* Experience setting up CI/CD pipelines and integrating static security scanning tools (SAST/dependency scanning).
* Understanding of the security risks associated with AI-generated code ("vibe coding") and how to implement automated controls within CI/CD pipelines is preferred.
* Security certifications such as **CEH or CompTIA Security+**, or experience working with government systems, is preferred.

Project timeline

You will be responsible for developing and integrating two systems within a 2-week period.**

Location: Hanoi.

Chú ý: Yêu cầu ở Hà Nội.
Backend/Tích hợp Developer
Mô tả công việc:
• Thiết kế và lập trình các module nghiệp vụ theo quy trình workflow (đăng ký – thẩm định – phê duyệt – ban hành) cho các hệ thống.
• Tích hợp API với hệ thống SSO, phân quyền, danh mục dùng chung của nền tảng lớn (qua LGSP).
• Thiết kế cơ sở dữ liệu Oracle, tối ưu truy vấn.
• Quản lý mã nguồn trên GitLab (Git Flow), viết Unit test (JUnit/Jest), đảm bảo pipeline CI/CD pass trước khi merge.
• Sử dụng Jira để cập nhật trạng thái task hàng ngày, Notion để tra cứu và đóng góp tài liệu kỹ thuật.
• Khuyến khích ứng dụng công cụ AI coding (Cursor, GitHub Copilot, Claude Code) để tăng tốc phần boilerplate/scaffolding, nhưng phải tuân thủ quy trình review bắt buộc trước khi đưa vào production.
• Phối hợp với đội DevOps để đảm bảo hiệu năng và bảo mật khi triển khai.
Yêu cầu:
• Tối thiểu 3-5 năm kinh nghiệm Java Spring Boot hoặc Node.js.
• Có kinh nghiệm làm việc với Oracle/PostgreSQL, thiết kế CSDL quan hệ.
• Hiểu biết về REST API, OAuth2/SSO, kiến trúc Microservices.
• Thành thạo Git/GitLab, có kinh nghiệm viết Unit test và làm việc với CI/CD pipeline.
• Ưu tiên có kinh nghiệm sử dụng công cụ AI coding agent (Cursor, GitHub Copilot, Claude Code) trong dự án thực tế và hiểu rõ giới hạn bảo mật khi dùng AI sinh code.
• Ưu tiên có kinh nghiệm dự án chính phủ điện tử, ngành công an/quốc phòng hoặc hệ thống yêu cầu bảo mật cao.

 
DevOps/Security Engineer
DevOps Engineer (Linux, Kubernetes, Bảo mật hệ thống) – Dự án hạ tầng CNTT
Mô tả công việc:
• Triển khai, vận hành hạ tầng máy chủ (Load Balancer, API Gateway, K8s cluster, Oracle RAC) trong môi trường mạng nội bộ khép kín (BCANet).
• Xây dựng cơ chế backup/restore, giám sát bằng ELK/Prometheus-Grafana, cảnh báo sự cố.
• Thiết lập và duy trì pipeline CI/CD trên GitLab, bao gồm bước quét bảo mật tự động cho toàn bộ code (kể cả code do AI sinh ra) trước khi merge vào production.
• Thực hiện kiểm thử bảo mật, đáp ứng tiêu chuẩn an toàn thông tin cấp độ 3.
• Xây dựng quy trình ứng cứu sự cố (Disaster Recovery), viết tài liệu vận hành lưu trên Notion.
• Theo dõi tiến độ và báo cáo trạng thái hạ tầng/bug hàng ngày qua Jira.
• Phối hợp với đội backend để tối ưu hiệu năng hệ thống, tư vấn về ranh giới an toàn khi dùng công cụ AI coding trong dự án.
Yêu cầu:
• Tối thiểu 3-5 năm kinh nghiệm quản trị hệ thống Linux, Kubernetes/Docker.
• Có kinh nghiệm với Oracle DB backup/HA, ELK stack, Prometheus/Grafana.
• Hiểu biết về an toàn thông tin, tiêu chuẩn ISO 27001 hoặc tương đương.
• Có kinh nghiệm thiết lập pipeline CI/CD và tích hợp công cụ quét bảo mật tĩnh (SAST/dependency scan).
• Ưu tiên hiểu biết về rủi ro bảo mật của code sinh bởi AI (vibe coding) và cách thiết lập cơ chế kiểm soát tự động trong pipeline.
• Ưu tiên có chứng chỉ bảo mật (CEH, CompTIA Security+) hoặc kinh nghiệm hệ thống chính phủ.

Bạn sẽ làm phát triển và tích hợp 2 hệ thống trong 2 tuần.

Skills: Java, Oracle, Node.js, PostgreSQL, GitLab, Kubernetes, DevOps, Microservices, CI/CD, REST API

Necesitamos un DevOps arquitecto en la nube, con 10+ años de experiencia. Su experiencia debe ser comprobable en OVH Cloud y otros.

Solo personas que hablen español.

Requisitos:

Habilidades técnicas.....
Gestión de infraestructura: Conocimiento en herramientas como Terraform, Ansible y Kubernetes.
Infraestructura: OVH cloud, máquinas virtuales y otros.

Automatización: Dominio de scripts y lenguajes como Bash, Python y PowerShell.

Control de versiones: Experiencia con Git y plataformas como GitHub .

Monitoreo y observabilidad: Manejo de Prometheus, Grafana y herramientas de logging como ELK Stack.

Seguridad: Implementación de políticas de seguridad y gestión de acceso (IAM, Firewalls, Zero Trust).

Habilidades blandas
Colaboración: Trabajo en equipo con desarrolladores, operadores y stakeholders.

Comunicación efectiva: Explicar conceptos técnicos a equipos no técnicos.

Resolución de problemas: Detectar y solucionar incidentes de manera rápida y eficiente.

Mentalidad de mejora continua: Búsqueda constante de optimización de procesos.


Con preferencia, sea Cristiano. Le esperamos.

Skills: Java, System Admin, Linux, Software Architecture, PostgreSQL, Ubuntu, Virtual Machines, Jenkins, Spring Boot, Terraform

We're looking for a Senior Backend Engineer with strong Rust experience to help design and build the backend systems powering our platform. This is a hands-on engineering role for someone who enjoys backend architecture, distributed systems, APIs, asynchronous programming, and performance optimization. Solana experience is a strong plus, but strong backend/Rust engineering experience is the primary requirement.

What You'll Do
-Design and develop backend services using Rust.
-Build REST APIs and asynchronous microservices.
-Integrate backend services with Solana RPC and on-chain programs.
-Design scalable backend architectures and data models.
-Build event-driven services for blockchain data and analytics.
-Work with PostgreSQL, Redis, and other backend infrastructure.
-Improve application performance, latency, reliability, and resource usage.
-Implement authentication, authorization, and security best practices.
-Write clean, maintainable, well-tested production code.
-Participate in architecture discussions and code reviews.
-Troubleshoot production issues and improve system reliability.
-Work closely with blockchain engineers, frontend developers, DevOps, and product teams.
-Contribute to CI/CD and deployment automation.

Required Experience
-4+ years of software development experience
-2+ years of professional backend development
-Strong professional experience with Rust
-Good understanding of asynchronous programming and Tokio / async Rust
-Experience building REST APIs and backend services
-Strong understanding of distributed systems and microservices
-Experience with PostgreSQL, Redis, or similar databases
-Experience with Docker
-Familiarity with Kubernetes
-Strong Git and CI/CD experience
-Strong debugging and performance-optimization skills
-Ability to write production-quality, maintainable code
-Strong communication and collaboration skills

Nice to Have
-Solana development experience
-Anchor Framework experience
-Experience working with Solana RPC APIs
-Blockchain indexing or event-processing experience
-Experience with Kafka, NATS, RabbitMQ, or similar messaging systems
-GraphQL or gRPC experience
-AWS, GCP, or Azure experience
-Prometheus, Grafana, or OpenTelemetry
-Experience operating high-availability production systems
-TypeScript experience

Technology Stack
-Backend: Rust, Tokio, Axum / Actix Web, SQLx / Diesel, REST, gRPC
-Database: PostgreSQL, Redis
-Infrastructure: Docker, Kubernetes, Linux, GitHub Actions
-Cloud: AWS / GCP
-Blockchain: Solana RPC, Anchor, Web3 APIs

What You'll Build
You'll contribute to backend infrastructure supporting:
-Staking
-DAO governance
-Treasury management
-Wallet integrations
-Blockchain analytics
-Developer APIs
-Authentication
-Notifications
-Blockchain event processing
-Data indexing
-Monitoring and observability

What We're Looking For
We're looking for an engineer who can do more than implement tickets. You should be comfortable asking architectural questions, identifying potential problems early, reviewing existing code, and making practical engineering decisions. You should also be able to work independently while communicating clearly with the rest of the engineering team.

Technical Assessment
Candidates who move forward will complete a practical Rust backend assessment.
The assessment will focus on:
-Rust proficiency
-API design
-Async/concurrent programming
-Database integration
-Code quality
-Testing
-Performance
-Backend architecture and problem-solving
The assessment is designed to take approximately 30 minutes.
Solana experience is helpful, but the assessment primarily evaluates backend and Rust engineering ability.

Hiring Process
1. Application / Resume Review
2. Rust Backend Technical Assessment
3. Technical Interview
4. System Design Interview
5. Final Interview
6. Offer

How to Apply
Please include:
-A brief introduction
-Your years of professional Rust experience
-Your backend development experience
-1–2 examples of production backend systems you've built
-Your experience with Solana/Web3, if any
-Your preferred employment type: Full-Time or Contract
-Your expected compensation/rate
-A link to GitHub or relevant technical work, if available

Please don't send a generic proposal. We are particularly interested in candidates who can clearly explain the backend systems they have personally designed and built.

We are seeking a skilled DevOps Engineer to manage our infrastructure and ensure smooth operations. The role involves setting up and maintaining servers, configuring networks, and optimizing system performance. The ideal candidate will have experience with Docker, WireGuard, and NVIDIA GPU, and be familiar with monitoring tools like Prometheus and Grafana. Experience with Keycloak for authentication and Redis for data storage is a plus. The candidate should be able to work independently and troubleshoot issues effectively.

We are seeking a skilled DevOps Engineer to manage our infrastructure and ensure smooth operations. The role involves setting up and maintaining servers, configuring networks, and optimizing system performance. The ideal candidate will have experience with Docker, WireGuard, and NVIDIA GPU, and be familiar with monitoring tools like Prometheus and Grafana. Experience with Keycloak for authentication and Redis for data storage is a plus. The candidate should be able to work independently and troubleshoot issues effectively.

I want a clean, responsive SLDC dashboard that lets my operations team see everything coming off our SCADA systems the moment it happens. All field values arrive through the IEC-104 protocol, so the first step is to convert those telegrams into a friendly structure (JSON or similar) that can be stored and queried without delay. From there, I need the data visualised in near real-time with clear trending, simple drill-downs and the ability to flag anomalies automatically.

Key deliverables
• IEC-104 data decoder and converter feeding a live database or time-series store
• Web-based dashboard that refreshes in real-time and runs on any modern browser
• Trending view with zoom, pan and export options
• Basic alert logic to highlight out-of-range values

The work sits inside an established utility environment, so reliability and low-latency processing are critical. If you are comfortable turning raw IEC-104 traffic into actionable web visuals—whether you prefer Python, Node-RED, Grafana, InfluxDB, TimescaleDB or another proven stack—let me know how you would tackle it and what sort of turnaround you can commit to.

Skills: Python, Web Development, Frontend Development, Data Visualization, Data Analysis, Database Management, Data Management

Job Title:
DevOps / Platform Engineer — (Immediate Start When Engaged)

Category: DevOps Engineering / Cloud Infrastructure / System Administration

Project Type: Ongoing, as-needed (bench/roster model — not continuous hours)

End-to-end DevOps pipeline design/build — CI/CD, IaC, containerization, deployment automation
Cloud migration execution (lift-and-shift, replatforming, or re-architecture)
Observability/SRE setup — monitoring, alerting, incident response tooling
Cloud cost optimization — rightsizing, reserved capacity, waste elimination
DevSecOps hardening — secrets management, IAM, network segmentation, CI/CD security gates
SOC 2 / ISO 27001 / HIPAA infrastructure-layer readiness work (not policy writing — the technical controls: logging, encryption, access controls, change management evidence)

Required skills:

Strong hands-on experience with AWS (primary); Azure or GCP a plus
Kubernetes, Terraform, Helm — production experience, not just tutorials
CI/CD tooling: GitHub Actions, ArgoCD, or equivalent
Docker and container orchestration
Observability stack experience (Datadog preferred, or similar — Prometheus/Grafana, New Relic, etc.)
Secrets management (Vault or cloud-native equivalents)
Comfortable reading and assessing someone else's infrastructure cold — not just building your own from scratch
Clear written communication — you'll often be producing an assessment doc or findings summary a client will read

Nice to have:

Experience supporting SOC 2 / compliance audits from the infra side
Startup/SaaS environment experience (not enterprise-only background)
Cost optimization / FinOps experience

About the project
We operate a network-level content filter — a service that carries a subscriber's internet traffic through a filtering
proxy that inspects and blocks content by policy (similar in shape to enterprise web filtering, parental-control
products, or ISP-level filtering services). The core is a custom proxy written in Go (TLS termination with our own CA,
image/text/category filtering, request rewriting), fronted by a WireGuard tunnel from the subscriber's device. The
filtering logic is built and proven on a live pilot box. What we need now is infrastructure and DevOps maturity to
turn it into a real product.

What you'll help us do
- Take the current single-node setup (one Hetzner box, hand-configured) to a repeatable, automated, multi-region
deployment (infra-as-code).
- Design and run high availability — right now one node is a single point of failure for every subscriber. We need
redundancy, health checks, failover, graceful drain.
- Build a distributed-egress architecture: a central filtering "brain" in a low-bandwidth-cost region plus lightweight
egress relays in other regions/countries (including hosting on a partner ISP's network), with per-destination
routing.
- Solve bandwidth-cost engineering — bandwidth is our dominant cost; we need metering, routing, and caching strategies that keep per-subscriber cost viable.
- Stand up observability: metrics, per-node/per-origin traffic accounting, alerting on the failure modes that are currently silent (stale policy, unreachable dependencies, egress-IP reputation decay).
- Harden secrets and PKI: we run a two-tier CA (offline root, per-node intermediates); we want this properly managed, rotated, and ideally HSM-backed as we scale.
- Improve CI/CD so signed builds deploy safely to many nodes with verification.

Required experience
- Deep Linux networking: routing, iptables/nftables, WireGuard (or OpenVPN/IPsec), tunnels, NAT, MTU/MSS, DNS.
- TLS at a systems level — termination, certificate/CA handling, MITM/inspection proxies, revocation, fingerprinting
basics.
- Running Go services in production (you don't need to be the app dev, but you should be comfortable in a Go codebase,
building, and debugging).
- systemd, nginx, cloud infra (Hetzner, AWS, and/or Israeli providers like Kamatera), and infra-as-code
(Terraform/Ansible or similar).
- Multi-region / HA / high-traffic experience — you've built something where uptime and bandwidth actually mattered.
- Solid observability practice (Prometheus/Grafana or equivalent) and an instinct for catching silent failures.

We're looking for a Senior Backend Software Engineer with 10+ years of experience to join our team long term.

We need someone who is strong in backend development, but also comfortable with system design, architecture, and product development.

What we're looking for:
- 10+ years of software engineering experience
- Strong backend development skills
- Strong system design and architecture skills
- Excellent coding and problem-solving skills
- Fluent English and strong communication
- Experience working with U.S. startups is a plus
- At least 5 hours of overlap with EST–PST working hours

You can be located anywhere in the world.

What you'll do:
- Build and improve backend systems
- Design scalable systems and architecture
- Develop new product features
- Make technical decisions
- Work closely with the team
- Take ownership from idea to production

We're looking for someone who can understand problems, suggest solutions, and drive development forward, not just follow tasks.

This is a long-term position. We're looking for someone who wants to grow with the company.

Telegram AI English Tutor Bot Development
Project Overview
We are looking for an experienced Python developer to build an AI-powered Telegram bot that helps users
learn and practice English.
The bot should communicate with users through text and voice messages, identify their English level,
correct mistakes, explain grammar, suggest better phrases, and generate personalized exercises.
The project should be developed as a production-ready MVP with a clean and extensible architecture.
Main User Flow
The user starts the bot using the /start command.
The bot asks the user to select:
Native language
Current English level
Learning goal
Preferred communication format
The user completes a short English level assessment.
The bot creates a basic learning profile.
The user can communicate with the AI tutor using text or voice messages.
The bot analyzes the user's messages, corrects mistakes, and continues the conversation.
The bot stores the user's progress and adapts future exercises to their level.
Target English Levels
The bot should support the following CEFR levels:
Beginner — A1
Elementary — A2
Intermediate — B1
Upper Intermediate — B2
Advanced — C1
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
•
•
•
•
•
1
Core Features
1. Telegram Bot
The bot must support:
/start
/help
/profile
/practice
/lesson
/vocabulary
/progress
/settings
/subscription
The interface should use Telegram inline buttons where appropriate.
2. AI Conversation Mode
The user should be able to have a natural conversation with the AI tutor.
The bot should:
Respond according to the user's English level
Keep answers concise and easy to understand
Correct grammar and vocabulary mistakes
Suggest more natural phrases
Explain corrections in the user's native language
Ask follow-up questions
Remember the context of the current conversation
Example:
User:
Yesterday I go to cinema with my friend.
Bot:
Yesterday I went to the cinema with my friend.
Explanation:
We use “went” because the action happened in the past.
“Went” is the past form of “go”.
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
2
Then the bot should continue the conversation:
What movie did you watch?
3. Conversation Modes
The user should be able to select a practice mode:
General conversation
Travel English
Business English
Job interview preparation
English for IT professionals
Grammar practice
Vocabulary practice
Role-playing scenarios
Example role-playing scenarios:
Ordering food in a restaurant
Checking into a hotel
Speaking with a recruiter
Participating in a work meeting
Talking to a customer
Going through airport security
4. Level Assessment
The bot should include a short initial assessment.
The assessment may contain:
Multiple-choice questions
Grammar questions
Vocabulary questions
Short written answers
A short conversation with the AI
Based on the answers, the bot should estimate the user's English level.
The assessment algorithm does not need to be academically certified. It should provide a reasonable
approximate result for personalization.
5. Personalized Lessons
The bot should generate short lessons based on:
User level
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
3
Learning goals
Previous mistakes
Recently learned vocabulary
Selected topic
Each lesson may include:
Short explanation
Examples
Exercise
User answer
AI feedback
Additional practice question
6. Mistake Tracking
The bot should store common user mistakes.
Mistake categories:
Grammar
Vocabulary
Word order
Articles
Prepositions
Verb tense
Spelling
Style and natural phrasing
The AI should use previous mistakes when generating future exercises.
7. Vocabulary Trainer
Users should be able to save words and phrases to their personal vocabulary list.
For every saved word, store:
Word or phrase
Translation
Example sentence
Date added
Number of correct answers
Number of incorrect answers
Next review date
The bot should periodically offer vocabulary revision exercises.
A simplified spaced-repetition algorithm is acceptable for the MVP.
•
•
•
•
1.
2.
3.
4.
5.
6.
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
4
8. Voice Messages
The bot should accept Telegram voice messages.
Required processing flow:
Receive Telegram voice message
Download the audio file
Convert audio when necessary
Transcribe speech using a speech-to-text API
Send the transcription to the LLM
Generate corrections and a response
Return a text response to the user
Optional feature:
Generate an audio response using a text-to-speech API
9. User Progress
The bot should show basic learning statistics:
Current English level
Number of completed lessons
Number of practice sessions
Number of learned words
Most common mistakes
Total study time
Current learning streak
The /progress command should display a short progress summary.
10. LLM Integration
The bot should support at least one LLM provider, such as:
OpenAI
Anthropic
Google Gemini
The LLM provider must be configurable through environment variables.
The implementation should separate the business logic from the specific LLM provider so another provider
can be added later.
The system prompt should include:
User level
1.
2.
3.
4.
5.
6.
7.
•
•
•
•
•
•
•
•
•
•
•
•
5
Native language
Learning goal
Current practice mode
Recent mistakes
Relevant conversation context
The bot must not send the entire conversation history to the LLM on every request.
A conversation summarization or limited-context strategy should be implemented.
11. Free and Premium Plans
The MVP should support two access levels.
Free plan:
Limited number of AI messages per day
Limited voice-message usage
Basic conversation mode
Basic progress statistics
Premium plan:
Higher or unlimited message limits
Voice-message support
Personalized lessons
Full progress history
Vocabulary trainer
All conversation modes
Payment integration may be implemented using Telegram Stars or another agreed payment provider.
For the first version, the developer may implement subscription status without real payments, provided the
architecture allows payment integration later.
12. Admin Features
A simple admin interface or admin commands should provide:
Total number of users
Number of active users
Number of new users
Number of LLM requests
Approximate token usage
Approximate API costs
User blocking
Granting or removing premium access
Sending a broadcast message
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
6
A web-based admin panel is optional for the MVP. Telegram admin commands are acceptable.
Technical Requirements
Preferred technology stack:
Python 3.12+
aiogram 3.x
FastAPI
PostgreSQL
SQLAlchemy 2.x
Alembic
Redis
OpenAI, Anthropic, or Gemini API
Docker
Docker Compose
Suggested architecture:
Telegram bot application
API or application service
LLM integration layer
Speech-to-text integration
Database layer
Background worker
Redis for caching and rate limiting
The project should use asynchronous Python where appropriate.
Suggested Database Entities
The database should include entities similar to:
User
ID
Telegram user ID
Username
Native language
English level
Learning goal
Subscription type
Subscription expiration date
Created date
Last activity date
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
7
Conversation
ID
User ID
Conversation mode
Short conversation summary
Created date
Updated date
Message
ID
Conversation ID
Role
Message text
Token usage
Created date
UserMistake
ID
User ID
Original text
Corrected text
Explanation
Mistake category
Created date
VocabularyItem
ID
User ID
Word or phrase
Translation
Example
Correct-answer count
Incorrect-answer count
Next review date
Lesson
ID
User ID
Topic
Level
Lesson content
Completion status
Created date
Completed date
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
8
UsageRecord
ID
User ID
Request type
Input tokens
Output tokens
Estimated cost
Created date
Rate Limiting and Cost Control
The system must include:
Daily message limits
Voice-message duration limits
Maximum input-message length
Maximum LLM response length
Per-user rate limiting
Protection from repeated requests
Token-usage logging
Configurable LLM model
Configurable daily limits
The bot should display a friendly message when a user reaches a limit.
Error Handling
The application should correctly handle:
Telegram API errors
LLM API timeouts
LLM rate limits
Invalid audio files
Speech-to-text failures
Database connection errors
Duplicate Telegram updates
Unexpected model responses
Errors should be logged without exposing sensitive information to users.
Security Requirements
API keys must be stored in environment variables.
Secrets must not be committed to the repository.
User input must be validated.
Admin functionality must be restricted by Telegram user ID.
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
9
Logs must not contain API keys or complete sensitive user data.
Webhook endpoints must be protected using a secret token.
Database queries must use the ORM or safe parameterized queries.
Deployment
The application should be delivered with:
Dockerfile
Docker Compose configuration
.env.example
Database migrations
Production startup instructions
Webhook configuration instructions
Basic backup instructions
The bot should be deployable to a standard VPS.
Possible deployment targets:
DigitalOcean
Hetzner
AWS
Google Cloud
Railway
Render
Testing
The project should include tests for the main business logic.
Minimum expected coverage:
User registration
English-level selection
Daily request limits
LLM service integration using mocks
Saving mistakes
Vocabulary review
Subscription-access checks
Telegram command handlers
External APIs must be mocked in automated tests.
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
10
Logging and Monitoring
The application should provide structured logs for:
Incoming requests
Telegram update processing
LLM requests
LLM response time
Token usage
Errors
Background tasks
Optional integrations:
Sentry
Prometheus
Grafana
Deliverables
The developer must provide:
Complete source code
Git repository
Docker configuration
Database migrations
.env.example
Setup and deployment documentation
Basic architecture documentation
Automated tests
API and LLM configuration instructions
A deployed working version of the bot
Development Milestones
Milestone 1 — Project Setup and Basic Telegram Bot
Project structure
Docker configuration
PostgreSQL integration
User registration
Basic commands
Settings and profile
Milestone 2 — LLM Tutor
LLM integration
•
•
•
•
•
•
•
•
•
•
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
•
•
•
•
•
•
•
11
Conversation mode
Prompt management
Grammar correction
Conversation context
Request limits
Milestone 3 — Learning Features
Level assessment
Lessons
Mistake tracking
Vocabulary trainer
Progress statistics
Milestone 4 — Voice and Subscription Features
Voice-message transcription
Premium-access logic
Usage and cost tracking
Admin commands
Milestone 5 — Testing and Deployment
Automated tests
Error handling
Production deployment
Documentation
Final bug fixing
Acceptance Criteria
The project will be considered complete when:
A new user can register and configure a learning profile.
The bot can hold an English conversation using an LLM.
The bot corrects user mistakes and explains corrections.
Conversation context is preserved.
User mistakes and vocabulary are stored.
The bot can generate personalized exercises.
Voice messages can be transcribed and processed.
Daily limits work correctly.
Admins can view basic usage statistics.
The project runs through Docker Compose.
Database migrations work on a clean database.
The main functionality is covered by automated tests.
Deployment and configuration instructions are provided.
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
12
Developer Requirements
Please apply only if you have practical experience with:
Python
Telegram Bot API
aiogram
FastAPI
PostgreSQL
AsyncIO
LLM APIs
Docker
Experience with speech-to-text APIs, subscription systems, RAG, Redis, and production deployment is a plus.
Questions for Applicants
Please include the following information in your proposal:
Examples of Telegram bots you have developed.
Examples of LLM integrations you have implemented.
Your suggested architecture for this project.
Which LLM provider you recommend and why.
How you would control token usage and API costs.
Your estimated development timeline.
Your fixed-price estimate or hourly rate.
Which functionality you would include in the first MVP

We're looking into the observability space and want to understand in detail how engineering teams work.

What you'll do (5–10 hrs/week to start): Showing us your real workflows in Grafana: how you build a dashboard from a raw data source, triage a firing alert back to a healthy service, take a query from Explore into a panel that someone else can actually read, and move dashboards and alert rules through a review process into production. And answering questions along the way: why this panel, what's the shortcut, where do people go wrong?

If you use Grafana regularly and can talk through your process clearly, you're exactly who we're looking for. No prep needed, just your day-to-day expertise.

Who you are (any of these backgrounds fits):
- Observability / Platform Engineer: you own the Grafana stack, data sources, dashboard standards, and the alerting rules built on top of them.
- SRE / Incident Responder: you live in Grafana during incidents, know which dashboard to open first, and keep alert noise from burying the signal.

Must-have: 5+ years of hands-on, near-daily use of Grafana (not just Datadog or New Relic); fluency with dashboard and panel authoring, template variables, at least one major data source (Prometheus, Loki, Tempo, Elasticsearch, or SQL), Grafana Alerting including notification policies and contact points, and folders/teams/permissions; able to articulate why you do what you do, not just drag panels around until it looks right.

Nice-to-have: experience across more than one of the profiles above; dashboards or alerts managed as code (provisioning, Terraform, Grizzly); Grafana Cloud and self-hosted OSS/Enterprise; migrations or integrations touching Grafana (Datadog, Splunk, PagerDuty, OnCall, k6) or admin of a large multi-team org.

Job Description:

We're Thoras AI, an early-stage AI startup building the future of autonomous Kubernetes infrastructure management. We're looking for a senior full-stack engineer to jump in, move fast, and own real product — not just tickets.

What you'll do:

Design and build core product features end-to-end — from data models and APIs to production-facing surfaces customers depend on
Work across our Kubernetes/cloud-native stack (AWS EKS, VPC, IAM, ECS, containers)
Identify failure modes before they become incidents — you've seen what tutorials don't cover
Sit with customers, develop product judgment, and translate conversations into filed issues and shipped fixes
Own your work from design through production

What we're looking for:

Strong backend fundamentals — you're at home designing data models, building APIs, and living in a database
Hands-on experience shipping software that production environments depend on across Kubernetes, ECS, EKS, and the broader cloud-native stack
Proficiency in Go, modern frontend frameworks, AWS (EKS, VPC, IAM), and Linux as daily tools
Product judgment — you don't just build what you're told, you can decide what's worth building
You've seen real failure modes in production, not just in tutorials

Nice to have:

Experience at an early-stage startup
Familiarity with infrastructure observability tools (Prometheus, Datadog, Grafana)
Experience with ML or AI infrastructure workloads

Engagement details:

Type: Contract / Freelance
Rate: $50–$75/hour
Hours: Part-time or full-time depending on fit
Timeline: Immediate start preferred

About Thoras AI:
Thoras is an AI-powered Kubernetes optimization platform that predicts infrastructure demand before it happens — so engineering teams scale before the spike, not after. We're a lean, fast-moving team building something that matters. You'll work directly with our founders and have real ownership over what you ship.

🌐 thoras.ai

Upwork Job Category: Engineering & Architecture → Full Stack Development

Skills tags to add:
Go · Kubernetes · AWS · Docker · EKS · PostgreSQL · REST APIs · Cloud Infrastructure · React · Linux

# RudderStack → PostHog & Grafana Product Analytics / BI Specialist

## Overview

We are looking for an experienced **RudderStack + PostHog + Grafana analytics specialist** to help us turn our web and mobile application events into useful, easy-to-understand business intelligence and observability dashboards.

Our data flow is:

**Web / iOS / Android → RudderStack → PostHog + Grafana**

The goal is to create reliable, well-organized analytics that help Product, Engineering, and Leadership understand what users are doing, quickly identify unusual behavior, and maintain everything independently after the engagement ends.

## Scope of Work

### Foundation & Data Quality

* Review our existing RudderStack event data and our PostHog and Grafana setup and configuration.
* Help define which events and metrics are actually worth monitoring.
* Improve event naming, properties, and organization where needed.
* Troubleshoot issues with events, data flow, queries, and visualizations.
* Recommend improvements to dashboard structure, queries, data models, and visualization approach.

### PostHog — Product Analytics & BI

* Organize and visualize important product events and user behaviors in PostHog.
* Build dashboards for key business/product metrics, including:
* User activity and engagement
* Conversion and funnel metrics
* Feature usage
* Video/content engagement
* Errors or unusual event patterns
* Web vs. mobile behavior
* Other important BI metrics identified during the project
* Configure **thresholds and anomaly alerts** for important metrics so we can identify significant changes or unexpected behavior.
* Create simple, executive-friendly dashboards that can be understood without technical knowledge.

### Grafana — Engineering & Advanced Visualization

* Build and improve Grafana dashboards for product and engineering analytics.
* Create advanced visualizations, especially **Sankey diagrams**, funnels, trends, distributions, and other useful charts.
* Model and visualize event data coming from RudderStack.
* Establish reusable dashboard/query patterns that our engineers can maintain.

### Documentation

* Document the dashboards, metrics, alert definitions, queries, and best practices.

## Knowledge Transfer — Required

This is **not just a dashboard-building project**.

You will work directly with our team — both technical and non-technical — and **teach them how to do this themselves**. For each piece of work, the goal is to leave behind enough knowledge, documentation, examples, and best practices for our team to reproduce, maintain, and extend the dashboards, metrics, and alerts independently.

Knowledge transfer should become part of our **Definition of Done (DoD)** for analytics/dashboard tickets.

## Ideal Candidate

* Strong hands-on **PostHog** experience.
* Strong hands-on **Grafana** experience, including Sankey diagrams and advanced visualizations.
* Strong **RudderStack** experience, including event tracking and data pipelines.
* Strong SQL/data analysis skills.
* Experience working with web and mobile product analytics and event data.
* Strong understanding of product/business metrics and BI dashboards.
* Experience defining meaningful KPIs, funnels, and anomaly thresholds.
* Able to turn raw event data into simple, actionable insights.
* Excellent communication and training skills — able to explain technical concepts clearly to both software engineers and non-technical stakeholders.

## Deliverables

1. PostHog analytics dashboards (product/BI metrics, funnels, user-behavior analysis).
2. Improved/new Grafana dashboards with advanced visualizations (Sankey diagrams, funnels, trends, distributions).
3. Anomaly thresholds and alerts for key metrics.
4. RudderStack/event-tracking recommendations and fixes.
5. Reusable queries and visualization patterns.
6. Documentation, examples, and metric/alert definitions.
7. Team training and knowledge-transfer sessions.
8. A repeatable process for our team to build and maintain dashboards, metrics, and alerts independently.

I’m expanding our platform and want an experienced DevOps engineer (minimum five-year track record) who can take ownership of our existing toolchain and push it forward. We already run production workloads on Kubernetes and monitor them with Grafana & Loki, so you’ll be coming into a live, container-centric environment.

Your first objectives will be:
• Audit and improve our current Kubernetes configuration, then handle ongoing deployment and maintenance.
• Extend the CI/CD pipeline so every change travels from Git commit to production automatically and safely.
• Fine-tune server-level settings, set up Cloudflare for optimal security and performance, and keep our observability stack healthy.

Beyond the core DevOps duties, you’ll collaborate with the application team on:
• RAG & LLM adjustments for our AI components.
• Integration work on the LiveAvatar TTS/SST systems.
• Scripting and light application tasks in Python (most critical) and, when useful, Node.js.

I’m open to either a half-time (≈20 hrs/week) or full-time engagement. Please outline:
1. A monthly price for 50 % capacity.
2. A monthly price for 100 % capacity.
3. Availability and a brief example of a similar Kubernetes-based project you’ve stabilised or scaled.

If you thrive in a fast-moving environment and can demonstrate solid, production-level results with Kubernetes, Grafana & Loki, CI/CD and Cloudflare, I’d love to talk.

Skills: Python, Linux, Node.js, Artificial Intelligence, Kubernetes, DevOps, Cloudflare, CI/CD, Retrieval-Augmented Generation (RAG)