The Indie Art Pipeline From Sketch to Sprite Sheet

An indie art pipeline moves from rough sketch to clean line art to flat color to animation frames to a packed sprite sheet ready for the engine. Each stage has a clear output, and the pipeline works when every stage finishes before the next one starts. Most teams lose time by skipping stages or by polishing too early, which creates rework when the design changes.

Why the pipeline matters

Without a pipeline, art is made to taste. Each asset takes a different path, quality varies, and revisions multiply because there is no shared checkpoint where problems are caught early.

A pipeline makes art production predictable. It tells you how long an asset takes, where it is in the process, and when it is done. That predictability is what lets a small team produce consistent art on a schedule.

The pipeline below fits a 2D game made by one to three people. Scale it by adding people at specific stages, not by changing the stages.

Stage one: rough sketch

The rough sketch answers one question: does this design read at game scale?

Draw it loose. Do not clean up edges. Do not worry about proportions. The purpose is to confirm the silhouette, the proportions relative to other game elements, and the personality.

Three things to check at this stage.

1. Silhouette. Shrink the sketch to game size on screen. If you cannot tell what it is from the outline alone, the design needs more contrast.
2. Scale. Place it next to existing assets. A character that reads well alone can look wrong next to environment art.
3. Animation potential. If this asset will be animated, check that the pose allows the movements you need. A standing pose with arms at the sides is hard to animate into a run.

Output: a rough sketch approved for cleanup. The approval can be a verbal yes from the lead or a checkmark on the task. What matters is that someone other than the artist confirmed it before cleanup starts.

Skip the rough sketch and you will clean up art that gets redesigned. The time saved by skipping is always less than the time lost to rework.

Stage two: line art

The line art stage produces a clean, consistent outline that defines the final shape.

Work at two to four times game resolution. Going higher wastes time on detail that disappears at final size. Going lower leaves no room for correction.

Line art rules for consistency across a project.

• Use a consistent line weight. Thicker outlines on the exterior, thinner on interior detail. This holds up at small sizes.
• Close all shapes. Open lines create fill problems in the color stage and selection problems in the animation stage.
• Keep the canvas size consistent. Every character on the same canvas size makes sprite sheet packing predictable.
• Separate the character from accessories. If a hat, weapon, or held object might change, draw it on a separate layer.

Tools vary by preference. Any raster editor with pressure-sensitive brush support works. Vector tools work for styles that suit them, but raster is more common for game sprites because it handles texture and hand-drawn quality better.

Stage three: flat color and shading

Color the line art using a limited palette chosen before production starts.

A shared palette keeps the game visually consistent even when multiple artists contribute. Twelve to twenty colors cover most indie games. Add variants for shading (a darker version of each base color) and highlights.

Three practices that save time.

• Fill on layers below the line art. This preserves the lines and allows easy color changes.
• Use flat color first, add shading second. Flat color at game scale is often enough, and it is faster to produce and easier to animate.
• Check the colors on the target device. Phone screens render color differently from monitors. Export a test sprite and view it on the phone before finalizing the palette.

Pick the approach that matches your time budget, not your ambition. Two-tone shading produces good results at game scale and takes roughly half the time of full painting.

Stage four: animation

Animation is where time estimates break. A character that took two hours to draw can take eight hours to animate, and underestimating this is the most common art pipeline mistake.

For frame-by-frame animation, the standard approach.

1. Block the keyframes. Draw the extreme positions of each animation: the contact frame of a walk, the apex of a jump, the windup and release of an attack.
2. Add in-betweens. Fill the frames between keyframes. For mobile at 30fps, most actions need four to eight frames. Idle and walk loops can work with as few as four.
3. Test the loop early. Preview the animation at game speed before finishing frames. Timing problems caught here save the most rework.

For bone-based animation (Spine, DragonBones), the process is different.

• Rig the character from the color stage output. Cut the character into pieces at the joints.
• Animate the rig. Keyframe the bones, and the software generates the in-betweens.
• Export sprite sheets from the animation software. The engine uses the sheet plus animation data.

Bone-based animation is faster for characters with many animations and produces smoother results with fewer frames. Frame-by-frame gives more artistic control and a hand-drawn feel. Choose based on your style and your animation count.

The feel of the animation matters more than the frame count. A four-frame run with good timing reads better than an eight-frame run with flat timing. The principles from 2D Game Feel: Camera and Tweening apply to sprite animation too.

Stage five: sprite sheet export

The final stage packs animation frames into a single texture for the engine.

Use a sprite packer tool. It arranges frames tightly, generates the texture atlas and the data file that tells the engine where each frame sits.

Three rules for clean export.

• Power-of-two textures. Not always required, but GPUs handle them more efficiently and some older devices expect them.
• Consistent padding. Add one or two pixels of padding between frames to prevent bleed at the edges. Most packers handle this automatically.
• Trim transparency. Remove empty space around each frame before packing. This reduces texture size significantly, and the packer records the offset so the engine reconstructs the position.

Name the output files predictably. A naming convention like character-action-direction (player-run-right.png) makes the engine integration faster and the project navigable months later.

For projects with many sprites, the build size implications are covered in Cut Your Unity Build Size in Half.

Common pipeline mistakes

Five patterns that cost indie teams the most time.

1. Polishing the sketch. A clean sketch is wasted work. The line art stage exists to produce the clean version.
2. Skipping the palette. Colors chosen per-asset drift across the project. A shared palette prevents this.
3. Animating before the design is approved. Animation is the most expensive stage. Animate only approved designs.
4. Working at final resolution. No room for correction. Work at 2x to 4x.
5. Exporting frames manually. Use a packer. Manual layout is slow and produces inconsistent results.

What we would do

Lock the palette and the canvas sizes before drawing the first asset. These two decisions affect every asset in the project, and changing them later means reworking everything already made.

Then enforce the stage gates. No line art without an approved sketch. No color without approved lines. No animation without approved color. Each gate is a five-minute conversation that prevents hours of rework.

Run the full pipeline on one asset first, from rough sketch through to a packed sprite sheet imported and running in the engine. That single end-to-end pass reveals every bottleneck and tool issue before you have fifty assets in progress.

The short version

• Five stages: rough sketch, line art, flat color, animation, sprite sheet export.
• Check silhouette and scale at sketch stage, before cleanup.
• Use a shared palette of twelve to twenty colors chosen before production starts.
• Animation takes longer than drawing. Budget accordingly and test loops early.
• Use a sprite packer for export. Name files predictably.
• Run the full pipeline on one asset before scaling to many.

Run one asset through the full pipeline this week. If you need an art pipeline built for your game, tell us about the project.

Related reading: 2D Game Feel: Camera and Tweening, How to Brief an Art Outsourcer, and Cut Your Unity Build Size in Half.