Back to jobs
New

Backend Software Engineer

Remote - USA

Who We Are
Gravwell is a full-stack security and observability platform built for people who need answers from their data—fast. Whether you're hunting threats, investigating incidents, or validating system health, Gravwell gives you the tools and performance to stay ahead. We're on a mission to simplify the SIEM experience without sacrificing power or flexibility.

What You’ll Do
As a Backend Software Engineer, you'll be responsible for the design, development, and testing of the Gravwell backend. You will be expected to take ownership of problems and work with the team to efficiently produce effective, well-tested solutions. 

Your Responsibilities

  • Application development for distributed systems
  • Profiling and optimizing performance
  • Scaling for large amounts of load, data, and users
  • Testing of backend application
  • On-call technical support on a rotating schedule

What We’re Looking For

  • Degree in computer science, computer engineering, or similar discipline.
  • 3+ years of experience with memory management and distributed systems.
  • Strong fundamentals including but not limited to:
    • Linux
    • File systems
    • Distributed systems
    • Storage systems
    • Memory management
    • Performance profiling
    • Application scaling
    • Networking
    • Machine Learning
  • Strong development skills
    • Go 
    • Syscall interfaces
  • Strong Git skills
    • Client proficiency
    • GitHub pull requests
  • Familiarity with software development life cycles
    • Defining requirements
    • Software design
    • Implementation
    • Unit testing and e2e testing
  • Strong verbal and written communication skills
    • Fluent in English

Nice to Have

  • Docker
  • Windows development
  • MacOS development
  • CUDA and/or ROCM

Why Gravwell?

  • Work where your impact is direct, visible, and appreciated
  • Full autonomy and trust to solve problems that we may not have known we had
  • Flexible remote work setup with a strong support culture
  • Access to mission-critical projects and real-world security data
  • Help build a better analytics experience

Compensation

Base Salary: $120,000 - $250,000

Don’t meet every single requirement?

That’s okay. We believe great teammates can learn new skills. If you bring curiosity, a strong work ethic, and a collaborative mindset, we can teach the rest. Gravwell is built by people who love solving problems together—we’d love to meet you.

Remote Position (United States)

Gravwell provides our employees with the flexibility to be creative and successful no matter where they are located. We have a flexible approach to work, meaning you can work from home, regardless of where you live within the United States. Gravwell provides flexible benefits and a collaborative work environment.

Equal Opportunity Employer

Gravwell is an Equal Opportunity Employer. All applicants will be considered for employment without attention to race, color, religion, sexual orientation, gender identity, national origin, veteran or disability status. Gravwell is a progressive and open-minded workplace where we do not tolerate discrimination of any kind. 

Apply for this job

*

indicates a required field

Resume/CV*

Accepted file types: pdf, doc, docx, txt, rtf

Cover Letter

Accepted file types: pdf, doc, docx, txt, rtf

Concurrency Challenge*

Accepted file types: pdf, doc, docx, txt, rtf

Write a Go program which does the following:

* Creates a synchronous channel of integers
* Launches 10 producer goroutines numbered 0 through 9, which attempt to write their number to the channel until signaled to exit. These goroutines should print a message when they start and when they exit.
* Launches a consumer goroutine which reads from the channel, printing each number it reads, until it is either signaled to exit or it has read 30 numbers. If 30 numbers are read, the consumer goroutine should return and signal the entire program to shut down. The consumer should sleep 500 milliseconds between each read from the channel. The consumer should print a message when it starts and when it exits.

The program should catch the os.Interrupt signal and properly shut down all goroutines if it is received. If no signal is received, the program should shut down once the consumer has read 30 numbers from the channel. The program should not exit until all goroutines have returned (printing their exit messages), at which point it should print "Main routine exiting" and exit.

Syscall Challenge*

Accepted file types: pdf, doc, docx, txt, rtf

Create a golang program that runs in Linux AMD64 using a modern golang runtime. Your program should perform the following tasks:

1. Create a file at the location `/tmp/test.bin`
2. Make that file 1024 bytes long
3. Fill that file with bytes that are sequentially increasing values % 0xFF (e.g. offset 0 is 0x0, offset 100 is 0x64, offset 1000 is 0xe8.
4. Properly close the file.
5. You may not import any library other than `syscall` from standard library.
6. You may not use Write() syscalls.
7. You must memory map the file in order to perform writes.

Riemann Challenge*

Accepted file types: pdf, doc, docx, txt, rtf

//go:build go1.20

// This program implements a Riemann sum of sin(x) over the interval [0,2π].
//
// This program also produces the wrong answer.
//
// Without removing the build constraint at the top of the file, identify and
// fix the program to correctly calculate the expected value. Also explain the
// bug, why it occurs, and why your fix works.

package main

import (
    "fmt"
    "math"
    "sync"
)

const π = math.Pi
const numPartitions = 101

func main() {
    var wg sync.WaitGroup
    vals := make(chan float64, numPartitions)

    f := func(x float64) float64 {
        return math.Sin(x)
    }

    a := float64(0)
    b := 2 * π
    n := float64(numPartitions)
    Δxᵢ := b / n

    var s float64
    for i := a; i < b; i += Δxᵢ {
        wg.Add(1)
        go func() {
            fₓ := f(i)
            vals <- fₓ
            wg.Done()
        }()
    }

    wg.Wait()
    close(vals)

    for fₓ := range vals {
        s += fₓ
    }
    s *= Δxᵢ

    expected := 0.0
    fmt.Printf("got %.4f, expected %.4f", s, expected)
}