Job Board

We hire for culture. We train for growth. We live our values.

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