Kamol’s Profile
  1. Topics/

Work Principles

Work Principles #

Welcome to my professional principles page! This is a collection of concepts, mindsets, and practices that guide my daily work. These principles have been refined through years of experience in software development and team leadership. While I’m always open to evolving these ideas, they’ve proven effective for me and the teams I’ve worked with.

Business Principles #

  • Value-First Approach: Prioritize business values over technology; technology should serve business needs, not the other way around.
  • Cost Optimization: Focus on creating cost-effective solutions that maximize business value while minimizing resource expenditure.
  • Sustainable Growth: Build systems and processes that can scale efficiently with business growth.

Software Development Principles #

  • Progressive Refinement: Follow Kent Beck’s mantra: “Make it work, make it right, make it fast” - in that specific order.
  • Solid Foundation: Design software components according to the SOLID principles (Robert C. Martin).
  • Code Clarity: Write clear, straightforward code rather than overly clever solutions - as advocated in The Elements of Programming Style by Kernighan and Plauger.
  • Critical Non-Functional Requirements (NFRs):
    • Maintainability: The foundation that enables all other aspects of quality software.
    • Performance: Essential for business viability and user satisfaction.
    • Security: Largely an art of information hiding and proper access control.

Maintainability Best Practices #

  • Minimalist Architecture: Fewer components lead to easier maintenance and fewer potential points of failure.
  • Test-First Development: Write tests before implementation to ensure code meets requirements and remains stable.
  • Comprehensive Automation: Automate all possible processes - testing, deployment, backup, monitoring, and maintenance.
  • Resilient Design: Create systems that prevent failures when possible and self-heal when necessary.

Performance Optimization #

  • I/O Efficiency: Minimize blocking I/O operations (network calls, disk access) to significantly enhance performance.
  • Asynchronous Processing: Utilize coroutine-friendly frameworks (e.g., Golang, PHP+Swoole) when blocking I/O is unavoidable.
  • Team Performance: Apply similar efficiency principles to team interactions to eliminate communication bottlenecks.

Security Implementation #

  • Information Hiding: Conceal server details by changing default session names and disabling server tokens.
  • Cost-Effective Protection: Utilize services like Cloudflare for their security benefits and CDN capabilities.
  • Regular Testing: Use free penetration testing tools like OWASP ZAP to continuously assess platform security.

Full-Stack Capability #

  • End-to-End Ownership: To build a successful startup platform independently, develop competency across the entire stack (Frontend, Backend, CI/CD, DevSecOps).
  • Integration Knowledge: Understanding how different components work together is more valuable than perfection in any single area.
  • Platform Control: Comprehensive knowledge gives you control over your platform’s destiny and evolution.

Team Leadership #

  • Earned Authority: Leadership must be earned through demonstrated competence and integrity, not merely assigned.
  • Leading by Example: Demonstrate the behaviors and work ethic you expect from your team.
  • Transparent Communication: Admit when you’re unsure and foster an environment where questions are encouraged.
  • Purpose-Driven Work: Ensure team members understand not just what they’re doing, but why their work matters.

Team Topologies #

by Manuel Pais and Matthew Skelton

  • Conway’s Law: “Any organization that designs a system will produce a design whose structure is a copy of the organization’s communication structure.”
  • Architectural Alignment: Team structures must align with the required software architecture to avoid unintended design outcomes.
  • Integrated Design: Software architecture cannot be designed in isolation and then implemented by any group of teams.
  • Engineering Foundation: Solid engineering practices are the foundation for effective team structures.
  • Cognitive Management: Limit team cognitive load and facilitate efficient team interactions to increase velocity.

The Pragmatic Programmer #

by Andrew Hunt and David Thomas

  • Quality Maintenance: Don’t leave broken windows (bad designs, poor code) unrepaired.
  • Critical Thinking: Analyze what you read and hear with a discerning mind.
  • Audience Awareness: Know your audience and tailor your communication accordingly.
  • Contract Design: Design by contract to clarify expectations and responsibilities.
  • Testable Code: Write code that’s easy to test to ensure reliability and maintainability.