Job Board

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

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