A web app that generates GitHub contribution-style posters from custom text, patterns, or data. Users can design pixel-style posters inspired by GitHub's contribution graph and export them as images.
Repository: bhedanikhilkumar-code/github-contribution-poster-maker
A web app that generates GitHub contribution-style posters from custom text, patterns, or data. Users can design pixel-style posters inspired by GitHub's contribution graph and export them as images.
This README is written as a portfolio-grade project document: it explains the product idea, technical approach, architecture, workflows, setup process, engineering standards, and future roadmap so a reviewer can understand both the codebase and the thinking behind it.
| Question | Answer |
|---|---|
| Who is it for? | Users, reviewers, recruiters, and developers who want to understand the project quickly. |
| What problem does it solve? | It turns a practical idea into a structured software project with clear workflows and maintainable implementation direction. |
| Why it matters? | The project demonstrates product thinking, stack selection, feature planning, and clean documentation discipline. |
| Current focus | Professional polish, understandable architecture, and portfolio-ready presentation. |
| Area | Details |
|---|---|
| Visibility | Public portfolio repository |
| Primary stack | TypeScript, React |
| Repository topics | contribution-graph, export, github, pixel-art, poster-generator, typescript, web-app |
| Useful commands | dev, build, start, lint, typecheck |
| Key dependencies | next, react, react-dom |
contribution-graph Β· export Β· github Β· pixel-art Β· poster-generator Β· typescript Β· web-app
| Capability | Description |
|---|---|
| Full-stack structure | Organizes UI, backend/API, state, and data flow for maintainable delivery. |
| User workflow focus | Built around practical screens, actions, and measurable outcomes. |
| API-ready design | Can grow with auth, persistence, validation, and service integrations. |
| Demo-friendly | Clear setup and documentation make it easier to run and review. |
| Document | Purpose |
|---|---|
| Architecture | System layers, workflow, data/state model, and extension points. |
| Case Study | Product framing, decisions, tradeoffs, and portfolio story. |
| Roadmap | Practical next steps for turning the project into a stronger product. |
| Quality Standard | Repository health checks, review standards, and quality gates. |
| Review Checklist | Final share/recruiter review checklist for a stronger GitHub impression. |
| Contributing | Branching, commit, review, and quality guidelines. |
| Security | Responsible disclosure and safe configuration notes. |
| Support | How to ask for help or report issues clearly. |
| Code of Conduct | Collaboration expectations for respectful project activity. |
flowchart TD
A[Discover project purpose] --> B[Understand main user workflow]
B --> C[Review architecture and stack]
C --> D[Run locally or inspect code]
D --> E[Evaluate quality and roadmap]
E --> F[Decide next improvement or deployment path]
| Layer | What reviewers should look for | Why it matters |
|---|---|---|
| Product | Clear user problem, target audience, and workflow | Shows product thinking beyond tutorial-level code |
| Interface | Screens, pages, commands, or hardware interaction points | Demonstrates how users actually experience the project |
| Logic | Validation, state transitions, service methods, processing flow | Proves the project can handle real use cases |
| Data | Local storage, database, files, APIs, or device input/output | Explains how information moves through the system |
| Quality | Tests, linting, setup clarity, and roadmap | Makes the project easier to trust, extend, and review |
| Entity / State | Purpose | Example fields or responsibilities |
|---|---|---|
| User input | Starts the main workflow | Form values, commands, uploaded files, device readings |
| Domain model | Represents the project-specific object | Transaction, note, shipment, event, avatar, prediction, song, or task |
| Service layer | Applies rules and coordinates actions | Validation, scoring, formatting, persistence, API calls |
| Storage/output | Keeps or presents the result | Database row, local cache, generated file, chart, dashboard, or device action |
| Feedback loop | Helps improve the next interaction | Status message, analytics, error handling, recommendations, roadmap item |
- Documentation-first presentation: A reviewer can understand the project without guessing the intent.
- Diagram-backed explanation: Architecture and workflow diagrams make the system easier to evaluate quickly.
- Real-world framing: The README describes users, outcomes, and operational flow rather than only listing files.
- Extension-ready roadmap: Future improvements are scoped so the project can keep growing cleanly.
- Portfolio alignment: The project is positioned as part of a consistent, professional GitHub portfolio.
flowchart LR
User[User] --> UI[Web UI / Views]
UI --> State[Client State & Forms]
State --> API[API / App Logic]
API --> Data[(Data Store / Files)]
API --> Integrations[External Integrations]
sequenceDiagram
participant U as User
participant A as Application
participant L as Logic Layer
participant D as Data/Device Layer
U->>A: Start workflow
A->>L: Process request
L->>D: Save/update state
D-->>L: State/result
L-->>A: Return useful result
A-->>U: Updated experience
github-contribution-poster-maker/
βββ π app
β βββ π api
β βββ π layout.tsx
β βββ π page.tsx
βββ π lib
β βββ π colorScale.ts
β βββ π contributionData.ts
β βββ π design.ts
β βββ π exportToPng.ts
β βββ π exportToSvg.ts
β βββ π font5x7.ts
β βββ π textToGrid.ts
βββ π components
β βββ π ContributionGrid.tsx
β βββ π ThemeToggle.tsx
βββ π styles
β βββ π globals.css
βββ π next-env.d.ts
βββ π next.config.ts
βββ π package.json
βββ π postcss.config.js
βββ π tailwind.config.ts
βββ π tsconfig.json
- Separation of concerns: UI, business logic, data/services, and platform concerns are documented as separate layers.
- Scalability mindset: The project structure is ready for new screens, services, tests, and deployment improvements.
- Portfolio quality: README content is designed to communicate value before someone even opens the code.
- Maintainability: Naming, setup steps, and roadmap items make future work easier to plan and review.
- User-first framing: Features are described by the value they provide, not just the technology used.
# 1. Install dependencies
npm install
# 2. Start development server
npm run dev
# 3. Build or validate production output
npm run buildBefore shipping or presenting this project, run the checks that match the stack:
| Check | Purpose |
|---|---|
| Format/lint | Keep code style consistent and reviewer-friendly. |
| Static analysis | Catch type, syntax, and framework-level issues early. |
| Unit/widget tests | Validate important logic and user-facing workflows. |
| Manual smoke test | Confirm the main flow works from start to finish. |
| README review | Ensure documentation matches the actual repository state. |
- Add automated tests
- Improve deployment documentation
- Create demo screenshots
- Expand feature roadmap
- Clear project purpose and audience
- Feature list aligned with real user workflows
- Architecture documented with diagrams
- Setup steps tested on a clean machine
- Screenshots or demo GIFs added where possible
- Environment variables documented without exposing secrets
- Tests/lint commands documented
- Roadmap shows practical next steps
Add these assets when available to make the repository even stronger:
| Asset | Recommended content |
|---|---|
| Hero screenshot | Main dashboard, home screen, or landing page |
| Workflow GIF | 10-20 second walkthrough of the core feature |
| Architecture image | Exported version of the Mermaid diagram |
| Before/after | Show how the project improves an existing workflow |
This project can be extended through focused, well-scoped improvements:
- Pick one feature or documentation improvement.
- Create a small branch with a clear name.
- Keep changes easy to review.
- Update this README if setup, features, or architecture changes.
- Open a pull request with screenshots or test notes when possible.
Add or update the license file based on how you want others to use this project. If this is a portfolio-only project, document that clearly before accepting external contributions.
Built and documented with a focus on professional presentation, practical workflows, and clean engineering communication.