Yêu cầu công việc
Must- Haves
Deep knowledge of Go and always updating your understanding of best practices
Leadership experience — you can guide a team and make tough technical decisions
Production experience with Go — you&039;ve seen real systems under real load
Happy and positive attitude — because building great software should be fun
Database skills — comfortable with SQL, database design, and performance optimization
Testing philosophy — you write tests that actually test business logic, not just coverage
Learning mindset — this is what you do every day, naturally
Understand life — challenges and victories are both part of the journey
Nice- to- Haves
Experience with PostgreSQL, CockroachDB, Redis, ClickHouse
Performance optimization and profiling skills
Docker/Kubernetes experience
Knowledge of Google Cloud Platform or similar
Understanding of microservices and distributed systems
Key Principles & Our "Real Go" Philosophy
What Makes Us Different
Feature- based organization — code is organized by what it does, not by architectural layers
Internal packages for shared code — proper encapsulation within modules
No Repository/Service layers unless necessary — we prefer simple functions over complex abstractions
HTTP 200 for business errors — clear separation between technical and business failures
Context for dependency injection — we use Go&039;s context package instead of DI frameworks
Real database testing — we test against actual databases, not mocks
Idiomatic Go Practices We Follow
Use gofmt and go vet — consistent formatting and static analysis
Composition over inheritance — embed structs and interfaces, avoid deep hierarchies
Error handling the Go way — explicit error returns, no exceptions or try- catch
Interfaces are discovered, not declared — small, focused interfaces defined by consumers
Prefer clarity over cleverness — readable code beats "smart" code every time
Zero values are useful — design types so their zero value is ready to use
Accept interfaces, return structs — flexible input, concrete output
Use Go modules properly — semantic versioning, minimal dependencies
Follow Go naming conventions — MixedCaps for exported, camelCase for unexported
Don&039;t panic in libraries — return errors instead, let callers decide
"Real Go" Testing Approach
Write focused tests — test actual working functions, not wrappers
Complete Isolation — each test case has its own database, no interference between tests
Don&039;t mock HTTP requests to make tests look fancy
No Complex Mock Objects — reduce time and errors from writing mock objects
Don&039;t use httptest for testing business logic
Real Test Data Preparation — create actual test data instead of mocking
Use Real Database instead of Mocks — create separate test databases for each test case
Test Real Business Logic — test validation, business rules, and database interactions together
Don&039;t test routing — test business logic directly
Automatic Setup/Teardown — databases are created and cleaned up automatically
Understand that good architecture = testable code without mocks
Understanding of Example Project Required
Understand using context for dependency injection
Deep dive into every file in the example project, understand the structure and rationale behind each package/module
Read and understand "This is real Go"
Understand the separation of business logic from transport layer
Understand database migration with embedded SQL files
Anti- patterns We Reject
Repository/Service layers everywhere — Don&039;t create interfaces just because "it&039;s good practice"
Interface for every struct — Interfaces should be discovered, not declared upfront
Dependency Injection frameworks — Use context instead of wire, dig, or fx
Factory patterns everywhere — Don&039;t create factories of factories
Manager/Controller/Service naming — If you need a "Manager", rethink your design
Deep inheritance hierarchies — Go doesn&039;t have classes for a reason
Java- style OOP in Go (We Don&039;t Want This)
Getters/Setters for everything — Use public fields when appropriate
Mocking everything — Test with real databases, not mock objects
🎯 Key Principles We Follow
Composition over inheritance — Embed structs, don&039;t create hierarchies
Real over mocked — Test against real systems when possible
Direct over abstracted — Don&039;t abstract until you need to
Functions over methods — Use functions unless you need state
Explicit over implicit — Clear dependencies, no magic
Simple over clever — Readable code beats "smart" code
🔍 Red Flags in Code Reviews
If we see these patterns, we&039;ll ask you to refactor:
- Multiple layers of abstraction for simple operations
- Interfaces created "just in case"
- Complex dependency injection setup
- Testing HTTP handlers instead of business logic
- Mocking databases for unit tests
- Manager/Service/Controller naming everywhere
- Deep struct embedding hierarchies
Tech Stack We Actually Use (No Bloat)
Core:
- Go (standard library focused)
- PostgreSQL / CockroachDB / Redis / ClickHouse
- Docker / Kubernetes
Infrastructure & DevOps:
- Google Cloud Platform
- GitHub Actions
- NATS / Google Cloud Pub/Sub
- Docker / Kubernetes
