Job Url: https://job-boards.greenhouse.io/gravwell/jobs/4111763009

Job Description: 
Back to jobs
New
Backend Software Engineer
Remote - USA
Team: Engineering
Reports to: VP of Product
Candidates must be US citizens or green card holders.

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

First Name*

Last Name*

Preferred First Name

Email*

Phone
Country


Phone

Resume/CV*
Attach
Enter manually
Accepted file types: pdf, doc, docx, txt, rtf

Cover Letter
Attach
Enter manually
Accepted file types: pdf, doc, docx, txt, rtf

Concurrency Challenge*
Attach
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*
Attach
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*
Attach
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)
}

Powered by